Recherche avancée

Sur d’autres sites (9638)

• Trying to get the current FPS and Frametime value into Matplotlib title

  16 juin 2022, par TiSoBr

  I try to turn an exported CSV with benchmark logs into an animated graph. Works so far, but I can't get the Titles on top of both plots with their current FPS and frametime in ms values animated.

  


  Thats the output I'm getting. Looks like he simply stores all values in there instead of updating them ?

  


  Screengrab of cli output
Screengrab of the final output (inverted)

  


  from __future__ import division
import sys, getopt
import time
import matplotlib
import numpy as np
import subprocess
import math
import re
import argparse
import os
import glob

import matplotlib.animation as animation
import matplotlib.pyplot as plt


def check_pos(arg):
    ivalue = int(arg)
    if ivalue <= 0:
        raise argparse.ArgumentTypeError("%s Not a valid positive integer value" % arg)
    return True
    
def moving_average(x, w):
    return np.convolve(x, np.ones(w), 'valid') / w
    

parser = argparse.ArgumentParser(
    description = "Example Usage python frame_scan.py -i mangohud -c '#fff' -o mymov",
    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", help = "Input data set from mangohud", required = True, nargs='+', type=argparse.FileType('r'), default=sys.stdin)
parser.add_argument("-o", "--output", help = "Output file name", required = True, type=str, default = "")
parser.add_argument("-r", "--framerate", help = "Set the desired framerate", required = False, type=float, default = 60)
parser.add_argument("-c", "--colors", help = "Colors for the line graphs; must be in quotes", required = True, type=str, nargs='+', default = 60)
parser.add_argument("--fpslength", help = "Configures how long the data will be shown on the FPS graph", required = False, type=float, default = 5)
parser.add_argument("--fpsthickness", help = "Changes the line width for the FPS graph", required = False, type=float, default = 3)
parser.add_argument("--frametimelength", help = "Configures how long the data will be shown on the frametime graph", required = False, type=float, default = 2.5)
parser.add_argument("--frametimethickness", help = "Changes the line width for the frametime graph", required = False, type=float, default = 1.5)
parser.add_argument("--graphcolor", help = "Changes all of the line colors on the graph; expects hex value", required = False, default = '#FFF')
parser.add_argument("--graphthicknes", help = "Changes the line width of the graph", required = False, type=float, default = 1)
parser.add_argument("-ts","--textsize", help = "Changes the the size of numbers marking the ticks", required = False, type=float, default = 23)
parser.add_argument("-fsM","--fpsmax", help = "Changes the the size of numbers marking the ticks", required = False, type=float, default = 180)
parser.add_argument("-fsm","--fpsmin", help = "Changes the the size of numbers marking the ticks", required = False, type=float, default = 0)
parser.add_argument("-fss","--fpsstep", help = "Changes the the size of numbers marking the ticks", required = False, type=float, default = 30)
parser.add_argument("-ftM","--frametimemax", help = "Changes the the size of numbers marking the ticks", required = False, type=float, default = 50)
parser.add_argument("-ftm","--frametimemin", help = "Changes the the size of numbers marking the ticks", required = False, type=float, default = 0)
parser.add_argument("-fts","--frametimestep", help = "Changes the the size of numbers marking the ticks", required = False, type=float, default = 10)

arg = parser.parse_args()
status = False


if arg.input:
    status = True
if arg.output:
    status = True
if arg.framerate:
    status = check_pos(arg.framerate)
if arg.fpslength:
    status = check_pos(arg.fpslength)
if arg.fpsthickness:
    status = check_pos(arg.fpsthickness)
if arg.frametimelength:
    status = check_pos(arg.frametimelength)
if arg.frametimethickness:
    status = check_pos(arg.frametimethickness)
if arg.colors:
    if len(arg.output) != len(arg.colors):
        for i in arg.colors:
            if re.match(r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$", i):
                status = True
            else:
                print('{} : Isn\'t a valid hex value!'.format(i))
                status = False
    else:
        print('You must have the same amount of colors as files in input!')
        status = False
if arg.graphcolor:
    if re.match(r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$", arg.graphcolor):
        status = True
    else:
        print('{} : Isn\'t a vaild hex value!'.format(arg.graphcolor))
        status = False
if arg.graphthicknes:
    status = check_pos(arg.graphthicknes)
if arg.textsize:
    status = check_pos(arg.textsize)
if not status:
    print("For a list of arguments try -h or --help") 
    exit()


# Empty output folder
files = glob.glob('/output/*')
for f in files:
    os.remove(f)


# We need to know the longest recording out of all inputs so we know when to stop the video
longest_data = 0

# Format the raw data into a list of tuples (fps, frame time in ms, time from start in micro seconds)
# The first three lines of our data are setup so we ignore them
data_formated = []
for li, i in enumerate(arg.input):
    t = 0
    sublist = []
    for line in i.readlines()[3:]:
        x = line[:-1].split(',')
        fps = float(x[0])
        frametime = int(x[1])/1000 # convert from microseconds to milliseconds
        elapsed = int(x[11])/1000 # convert from nanosecond to microseconds
        data = (fps, frametime, elapsed)
        sublist.append(data)
    # Compare last entry of each list with the 
    if sublist[-1][2] >= longest_data:
        longest_data = sublist[-1][2]
    data_formated.append(sublist)


max_blocksize = max(arg.fpslength, arg.frametimelength) * arg.framerate
blockSize = arg.framerate * arg.fpslength


# Get step time in microseconds
step = (1/arg.framerate) * 1000000 # 1000000 is one second in microseconds
frame_size_fps = (arg.fpslength * arg.framerate) * step
frame_size_frametime = (arg.frametimelength * arg.framerate) * step


# Total frames will have to be updated for more then one source
total_frames = int(int(longest_data) / step)


if True: # Gonna be honest, this only exists so I can collapse this block of code

    # Sets up our figures to be next to each other (horizontally) and with a ratio 3:1 to each other
    fig, (ax1, ax2) = plt.subplots(1, 2, gridspec_kw={'width_ratios': [3, 1]})

    # Size of whole output 1920x360 1080/3=360
    fig.set_size_inches(19.20, 3.6)

    # Make the background transparent
    fig.patch.set_alpha(0)


    # Loop through all active axes; saves a lot of lines in ax1.do_thing(x) ax2.do_thing(x)
    for axes in fig.axes:

        # Set all splines to the same color and width
        for loc, spine in axes.spines.items():
            axes.spines[loc].set_color(arg.graphcolor)
            axes.spines[loc].set_linewidth(arg.graphthicknes)

        # Make sure we don't render any data points as this will be our background
        axes.set_xlim(-(max_blocksize * step), 0)
        

        # Make both plots transparent as well as the background
        axes.patch.set_alpha(.5)
        axes.patch.set_color('#020202')

        # Change the Y axis info to be on the right side
        axes.yaxis.set_label_position("right")
        axes.yaxis.tick_right()

        # Add the white lines across the graphs; the location of the lines are based off set_{}ticks
        axes.grid(alpha=.8, b=True, which='both', axis='y', color=arg.graphcolor, linewidth=arg.graphthicknes)

        # Remove X axis info
        axes.set_xticks([])

    # Add a another Y axis so ticks are on both sides
    tmp_ax1 = ax1.secondary_yaxis("left")
    tmp_ax2 = ax2.secondary_yaxis("left")

    # Set both to the same values
    ax1.set_yticks(np.arange(arg.fpsmin, arg.fpsmax + 1, step=arg.fpsstep))
    ax2.set_yticks(np.arange(arg.frametimemin, arg.frametimemax + 1, step=arg.frametimestep))
    tmp_ax1.set_yticks(np.arange(arg.fpsmin , arg.fpsmax + 1, step=arg.fpsstep))
    tmp_ax2.set_yticks(np.arange(arg.frametimemin, arg.frametimemax + 1, step=arg.frametimestep))

    # Change the "ticks" to be white and correct size also change font size
    ax1.tick_params(axis='y', color=arg.graphcolor ,width=arg.graphthicknes, length=16, labelsize=arg.textsize, labelcolor=arg.graphcolor)
    ax2.tick_params(axis='y', color=arg.graphcolor ,width=arg.graphthicknes, length=16, labelsize=arg.textsize, labelcolor=arg.graphcolor)
    tmp_ax1.tick_params(axis='y', color=arg.graphcolor ,width=arg.graphthicknes, length=8, labelsize=0) # Label size of 0 disables the fps/frame numbers
    tmp_ax2.tick_params(axis='y', color=arg.graphcolor ,width=arg.graphthicknes, length=8, labelsize=0)


    # Limits Y scale
    ax1.set_ylim(arg.fpsmin,arg.fpsmax + 1)
    ax2.set_ylim(arg.frametimemin,arg.frametimemax + 1)

    # Add an empty plot
    line = ax1.plot([], lw=arg.fpsthickness)
    line2 = ax2.plot([], lw=arg.frametimethickness)

    # Sets all the data for our benchmark
    for benchmarks, color in zip(data_formated, arg.colors):
        y = moving_average([x[0] for x in benchmarks], 25)
        y2 = [x[1] for x in benchmarks]
        x = [x[2] for x in benchmarks]
        line += ax1.plot(x[12:-12],y, c=color, lw=arg.fpsthickness)
        line2 += ax2.step(x,y2, c=color, lw=arg.fpsthickness)
    
    # Add titles with values
    ax1.set_title("Avg. frames per second: {}".format(y2), color=arg.graphcolor, fontsize=20, fontweight='bold', loc='left')
    ax2.set_title("Frametime in ms: {}".format(y2), color=arg.graphcolor, fontsize=20, fontweight='bold', loc='left')  

    # Removes unwanted white space; also controls the space between the two graphs
    plt.tight_layout(pad=0, h_pad=0, w_pad=2.5)
    
    fig.canvas.draw()

    # Cache the background
    axbackground = fig.canvas.copy_from_bbox(ax1.bbox)
    ax2background = fig.canvas.copy_from_bbox(ax2.bbox)


# Create a ffmpeg instance as a subprocess we will pipe the finished frame into ffmpeg
# encoded in Apple QuickTime (qtrle) for small(ish) file size and alpha support
# There are free and opensource types that will also do this but with much larger sizes
canvas_width, canvas_height = fig.canvas.get_width_height()
outf = '{}.mov'.format(arg.output)
cmdstring = ('ffmpeg',
                '-stats', '-hide_banner', '-loglevel', 'error', # Makes ffmpeg less annoying / to much console output
                '-y', '-r', '60', # set the fps of the video
                '-s', '%dx%d' % (canvas_width, canvas_height), # size of image string
                '-pix_fmt', 'argb', # format cant be changed since this is what  `fig.canvas.tostring_argb()` outputs
                '-f', 'rawvideo',  '-i', '-', # tell ffmpeg to expect raw video from the pipe
                '-vcodec', 'qtrle', outf) # output encoding must support alpha channel
pipe = subprocess.Popen(cmdstring, stdin=subprocess.PIPE)

def render_frame(frame : int):

    # Set the bounds of the graph for each frame to render the correct data
    start = (frame * step) - frame_size_fps
    end = start + frame_size_fps
    ax1.set_xlim(start,end)
     
     
    start = (frame * step) - frame_size_frametime
    end = start + frame_size_frametime
    ax2.set_xlim(start,end)
    

    # Restore background
    fig.canvas.restore_region(axbackground)
    fig.canvas.restore_region(ax2background)

    # Redraw just the points will only draw points with in `axes.set_xlim`
    for i in line:
        ax1.draw_artist(i)
        
    for i in line2:
        ax2.draw_artist(i)

    # Fill in the axes rectangle
    fig.canvas.blit(ax1.bbox)
    fig.canvas.blit(ax2.bbox)
    
    fig.canvas.flush_events()

    # Converts the finished frame to ARGB
    string = fig.canvas.tostring_argb()
    return string




#import multiprocessing
#p = multiprocessing.Pool()
#for i, _ in enumerate(p.imap(render_frame, range(0, int(total_frames + max_blocksize))), 20):
#    pipe.stdin.write(_)
#    sys.stderr.write('\rdone {0:%}'.format(i/(total_frames + max_blocksize)))
#p.close()

#Signle Threaded not much slower then multi-threading
if __name__ == "__main__":
    for i , _ in enumerate(range(0, int(total_frames + max_blocksize))):
        render_frame(_)
        pipe.stdin.write(render_frame(_))
        sys.stderr.write('\rdone {0:%}'.format(i/(total_frames + max_blocksize)))


  


• How to extract elementary video from mp4 using ffmpeg programmatically ?

  24 octobre 2019, par epipav

  I have started learning ffmpeg few weaks ago. At the moment I am able to transcode any video to mp4 using h264/AVC codec. The main scheme is something like that :

  -open input
  
  -demux
  
  -decode
  
  -encode
  
  -mux

  The actual code is below :

  #include <iostream>
  
  
  
  #include 
  
  
  
  extern "C" {
  
  
  
    #
  
    ifndef __STDC_CONSTANT_MACROS# undef main /* Prevents SDL from overriding main() */ # define __STDC_CONSTANT_MACROS# endif
  
  
  
    # pragma comment(lib, "avcodec.lib")# pragma comment(lib, "avformat.lib")# pragma comment(lib, "swscale.lib")# pragma comment(lib, "avutil.lib")
  
  
  
    #include 
  
    #include 
  
    #include 
  
    #include 
  
    #include <libavutil></libavutil>opt.h>
  
    #include 
  
    #include 
  
    #include 
  
    #include 
  
    #include 
  
  }
  
  
  
  using namespace std;
  
  
  
  void open_video(AVFormatContext * oc, AVCodec * codec, AVStream * st) {
  
    int ret;
  
    AVCodecContext * c;
  
    c = st - > codec;
  
  
  
    /*open codec */
  
  
  
    cout &lt;&lt; "probably starts here" &lt;&lt; endl;
  
    ret = avcodec_open2(c, codec, NULL);
  
    cout &lt;&lt; "and ends here" &lt;&lt; endl;
  
  
  
    if (ret &lt; 0) {
  
      cout &lt;&lt; ("Could not open video codec") &lt;&lt; endl;
  
    }
  
  
  
  }
  
  
  
  /*This function will add a new stream to our file.
  
  @param
  
  oc -> Format context that the new stream will be added.
  
  codec -> codec of the stream, this will be passed.
  
  codec_id -> 
  
  chWidth->
  
  chHeight->
  
  */
  
  
  
  AVStream * addStream(AVFormatContext * oc, AVCodec ** codec, enum AVCodecID codec_id, int chWidth, int chHeight, int fps) {
  
    AVCodecContext * c;
  
    AVStream * st;
  
  
  
    //find encoder of the stream, it passes this information to @codec, later on
  
    //it will be used in encoding the video @ avcodec_encode_video2 in loop.
  
    * codec = avcodec_find_encoder(AV_CODEC_ID_H264);
  
  
  
    if (( * codec) == NULL)
  
      cout &lt;&lt; "ERROR CAN NOT FIND ENCODER! ERROR! ERROR! AVCODEC_FIND_ENCODER FAILED !!!1 "
  
    "" &lt;&lt; endl;
  
  
  
    if (!( * codec))
  
      printf("Could not find encoder for ' %s ' ", avcodec_get_name(codec_id));
  
  
  
    //create a new stream with the found codec inside oc(AVFormatContext).
  
    st = avformat_new_stream(oc, * codec);
  
  
  
    if (!st)
  
      cout &lt;&lt; " Cannot allocate stream " &lt;&lt; endl;
  
  
  
    //Setting the stream id.
  
    //Since, there can be other streams in this AVFormatContext,
  
    //we should find the first non used index. And this is oc->nb_streams(number of streams) - 1
  
    st - > id = oc - > nb_streams - 1;
  
  
  
    c = st - > codec;
  
  
  
    //setting the stream's codec's properties.
  
    c - > codec_id = codec_id;
  
    c - > bit_rate = 4000000;
  
    c - > width = chWidth;
  
    c - > height = chHeight;
  
    c - > time_base.den = fps;
  
    //fps;
  
    c - > time_base.num = 1;
  
    c - > gop_size = 12;
  
    c - > pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
    if (c - > codec_id == AV_CODEC_ID_MPEG2VIDEO) {
  
      /* just for testing, we also add B frames */
  
      c - > max_b_frames = 2;
  
    }
  
  
  
    if (c - > codec_id == AV_CODEC_ID_MPEG1VIDEO) {
  
      /* Needed to avoid using macroblocks in which some coeffs overflow.
  
       * This does not happen with normal video, it just happens here as
  
       * the motion of the chroma plane does not match the luma plane. */
  
      c - > mb_decision = 2;
  
    }
  
  
  
    /* Some formats want stream headers to be separate. */
  
    if (oc - > oformat - > flags &amp; AVFMT_GLOBALHEADER)
  
      c - > flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  
  
    //returning our lovely new brand stream.
  
    return st;
  
  
  
  }
  
  
  
  int changeResolution(string source, int format) {
  
    //Data members
  
    struct SwsContext * sws_ctx = NULL;
  
    AVFrame * pFrame = NULL;
  
    AVFrame * outFrame = NULL;
  
    AVPacket packet;
  
    uint8_t * buffer = NULL;
  
    uint8_t endcode[] = {
  
      0,
  
      0,
  
      1,
  
      0xb7
  
    };
  
    AVDictionary * optionsDict = NULL;
  
    AVFormatContext * pFormatCtx = NULL;
  
    AVFormatContext * outputContext = NULL;
  
    AVCodecContext * pCodecCtx;
  
    AVCodec * pCodec;
  
    AVCodec * codec;
  
    AVCodec * videoCodec;
  
    AVOutputFormat * fmt;
  
    AVStream * video_stream;
  
    int changeWidth;
  
    int changeHeight;
  
    int frameFinished;
  
    int numBytes;
  
    int fps;
  
  
  
    int lock = 0;
  
  
  
    //Register all codecs &amp; other important stuff. Vital!..
  
    av_register_all();
  
  
  
    //Selects the desired resolution.
  
    if (format == 0) {
  
      changeWidth = 320;
  
      changeHeight = 180;
  
    } else if (format == 1) {
  
      changeWidth = 640;
  
      changeHeight = 480;
  
  
  
    } else if (format == 2) {
  
      changeWidth = 960;
  
      changeHeight = 540;
  
  
  
    } else if (format == 3) {
  
      changeWidth = 1024;
  
      changeHeight = 768;
  
  
  
    } else {
  
      changeWidth = 1280;
  
      changeHeight = 720;
  
    }
  
  
  
    // Open video file
  
    int aaa;
  
    aaa = avformat_open_input( &amp; pFormatCtx, source.c_str(), NULL, NULL);
  
    if (aaa != 0) {
  
      cout &lt;&lt; " cannot open input file \n" &lt;&lt; endl;
  
      cout &lt;&lt; "aaa = " &lt;&lt; aaa &lt;&lt; endl;
  
      return -1; // Couldn't open file    
  
    }
  
  
  
    // Retrieve stream information
  
    if (av_find_stream_info(pFormatCtx) &lt; 0)
  
      return -1; // Couldn't find stream information
  
  
  
    //just checking duration casually for no reason
  
    /*int64_t duration = pFormatCtx->duration;
  
  
  
    cout &lt;&lt; "the duration is " &lt;&lt; duration &lt;&lt; " " &lt;&lt; endl;*/
  
  
  
    //this writes the info about the file
  
    av_dump_format(pFormatCtx, 0, 0, 0);
  
    cin >> lock;
  
  
  
    // Find the first video stream
  
    int videoStream = -1;
  
    int i;
  
  
  
    for (i = 0; i &lt; 3; i++)
  
      if (pFormatCtx - > streams[i] - > codec - > codec_type == AVMEDIA_TYPE_VIDEO) {
  
        videoStream = i;
  
        cout &lt;&lt; " lel \n ";
  
        break;
  
  
  
      }
  
  
  
    if (videoStream == -1)
  
      return -1; // Didn't find a video stream
  
  
  
    // Get a pointer to the codec context for the video stream
  
    pCodecCtx = pFormatCtx - > streams[videoStream] - > codec;
  
    fps = pCodecCtx - > time_base.den;
  
  
  
    //Find the decoder of the input file, for the video stream
  
    pCodec = avcodec_find_decoder(pCodecCtx - > codec_id);
  
  
  
    if (pCodec == NULL) {
  
      fprintf(stderr, "Unsupported codec!\n");
  
      return -1; // Codec not found
  
    }
  
  
  
    // Open codec, you must open it first, in order to use it.
  
    if (avcodec_open2(pCodecCtx, pCodec, &amp; optionsDict) &lt; 0)
  
      return -1; // Could not open codec
  
  
  
    // Allocate video frame ( pFrame for taking the packets into, outFrame for processed frames to packet.)
  
    pFrame = avcodec_alloc_frame();
  
    outFrame = avcodec_alloc_frame();
  
  
  
    i = 0;
  
  
  
    int ret;
  
    int video_frame_count = 0;
  
  
  
    //Initiate the outFrame set the buffer &amp; fill the properties
  
    numBytes = avpicture_get_size(PIX_FMT_YUV420P, changeWidth, changeHeight);
  
    buffer = (uint8_t * ) av_malloc(numBytes * sizeof(uint8_t));
  
    avpicture_fill((AVPicture * ) outFrame, buffer, PIX_FMT_YUV420P, changeWidth, changeHeight);
  
  
  
    int pp;
  
    int frameNo = 0;
  
  
  
    //allocate the outputContext, it will be the AVFormatContext of our output file. 
  
    //It will try to find the format by giving the file name.
  
    avformat_alloc_output_context2( &amp; outputContext, NULL, NULL, "myoutput.mp4");
  
  
  
    //Cant find the file extension, using MPEG as default.
  
    if (!outputContext) {
  
      printf("Could not deduce output format from file extension: using MPEG.\n");
  
      avformat_alloc_output_context2( &amp; outputContext, NULL, "mpeg", "myoutput.mp4");
  
    }
  
  
  
    //Still cant set file extension, exit.
  
    if (!outputContext) {
  
      return 1;
  
    }
  
  
  
    //set AVOutputFormat fmt to our outputContext's format.
  
    fmt = outputContext - > oformat;
  
    video_stream = NULL;
  
  
  
    //If fmt has a valid codec_id, create a new video stream.
  
    //This function will set the streams codec &amp; codecs desired properties.
  
    //Stream's codec will be passed to videoCodec for later usage.
  
    if (fmt - > video_codec != AV_CODEC_ID_NONE)
  
      video_stream = addStream(outputContext, &amp; videoCodec, fmt - > video_codec, changeWidth, changeHeight, fps);
  
  
  
    //open the video using videoCodec. by avcodec_open2() i.e open the codec.
  
    if (video_stream)
  
      open_video(outputContext, videoCodec, video_stream);
  
  
  
    //Creating our new output file.
  
    if (!(fmt - > flags &amp; AVFMT_NOFILE)) {
  
      ret = avio_open( &amp; outputContext - > pb, "toBeStreamed.264", AVIO_FLAG_WRITE);
  
      if (ret &lt; 0) {
  
        cout &lt;&lt; " cant open file " &lt;&lt; endl;
  
        return 1;
  
      }
  
    }
  
  
  
    //Writing the header of format context.
  
    //ret = avformat_write_header(outputContext, NULL);
  
  
  
    if (ret >= 0) {
  
      cout &lt;&lt; "writing header success !!!" &lt;&lt; endl;
  
    }
  
  
  
    //Start reading packages from input file.
  
    while (av_read_frame(pFormatCtx, &amp; packet) >= 0) {
  
  
  
      // Is this a packet from the video stream?  
  
      if (packet.stream_index == videoStream) {
  
  
  
        // Decode video package into frames
  
        ret = avcodec_decode_video2(pCodecCtx, pFrame, &amp; frameFinished, &amp; packet);
  
  
  
        if (ret &lt; 0) {
  
          printf(" Error decoding frame !!..");
  
          return ret;
  
        }
  
  
  
        if (frameFinished) {
  
          printf("video_frame n:%d    coded_n:%d\n", video_frame_count++, pFrame - > coded_picture_number);
  
        }
  
  
  
        av_free_packet( &amp; packet);
  
  
  
        //do stuff with frame, in this case we are changing the resolution.
  
        static struct SwsContext * img_convert_ctx_in = NULL;
  
        if (img_convert_ctx_in == NULL) {
  
          img_convert_ctx_in = sws_getContext(pCodecCtx - > width,
  
            pCodecCtx - > height,
  
            pCodecCtx - > pix_fmt,
  
            changeWidth,
  
            changeHeight,
  
            PIX_FMT_YUV420P,
  
            SWS_BICUBIC,
  
            NULL,
  
            NULL,
  
            NULL);
  
  
  
        }
  
        //scale the frames
  
        sws_scale(img_convert_ctx_in,
  
          pFrame - > data,
  
          pFrame - > linesize,
  
          0,
  
          pCodecCtx - > height,
  
          outFrame - > data,
  
          outFrame - > linesize);
  
  
  
        //initiate the pts value
  
        if (frameNo == 0)
  
          outFrame - > pts = 0;
  
  
  
        //calculate the pts value &amp; set it.
  
        outFrame - > pts += av_rescale_q(1, video_stream - > codec - > time_base, video_stream - > time_base);
  
  
  
        //encode frames into packages. Package passed in @packet.
  
        if (avcodec_encode_video2(outputContext - > streams[0] - > codec, &amp; packet, outFrame, &amp; pp) &lt; 0)
  
          cout &lt;&lt; "Encoding frames into packages, failed. " &lt;&lt; endl;
  
  
  
        frameNo++;
  
  
  
        //write the packages into file, resulting in creating a video file.
  
        av_interleaved_write_frame(outputContext, &amp; packet);
  
  
  
      }
  
  
  
    }
  
  
  
    av_free_packet( &amp; packet);
  
    //av_write_trailer(outputContext);
  
  
  
    avio_close(outputContext - > pb);
  
  
  
    // Free the RGB image
  
    av_free(buffer);
  
    av_free(outFrame);
  
  
  
    // Free the YUV frame
  
    av_free(pFrame);
  
  
  
    // Close the codec
  
    avcodec_close(video_stream - > codec);
  
    avcodec_close(pCodecCtx);
  
  
  
    // Close the video file
  
    avformat_close_input( &amp; pFormatCtx);
  
  
  
    return 0;
  
  }
  
  </iostream>

  at the end of the process I get my desired file with desired codec & container & resolution.

  My problem is, in a part of our project I need to get elementary video streams IN file. Such as example.264. However I can not add a stream without creating an AVFormatContext. I can not create an AVFormatContext because 264 files does not have a container,they are just raw video ?, as far as I know.

  I have tried the way in decoding_encoding.c which uses fwrite. However that example was for mpeg-2 codec and when I try to adapt that code to H264/AVC codec, I got "floating point division by zero" error from mediainfo and moreover, some of the properties of the video was not showing (such as FPS & playtime & quality factor). I think it has to do with the "endcode" the example adds at the end of the code. It is for mpeg-2. ( uint8_t endcode[] = 0, 0, 1, 0xb7  ; )

  Anyway, I would love to get a startpoint for this task. I have managed to come this far by using internet resources ( quite few & outdated for ffmpeg) but now I’m stuck a little.

• How to extract elementary video from mp4 using ffmpeg programmatically ?

  4 juillet 2013, par epipav

  I have started learning ffmpeg few weaks ago. At the moment I am able to transcode any video to mp4 using h264/AVC codec. The main scheme is something like that :

  -open input
   demux
   decode
   encode
   mux

  The actual code is below :

  #include <iostream>
  
  #include 
  
  extern "C" 
  
  {
  
  
  
  #ifndef __STDC_CONSTANT_MACROS
  
  #undef main /* Prevents SDL from overriding main() */
  
  #  define __STDC_CONSTANT_MACROS
  
  #endif
  
  
  
  
  
  
  
  #pragma comment (lib,"avcodec.lib")
  
  #pragma comment (lib,"avformat.lib")
  
  #pragma comment (lib,"swscale.lib")
  
  #pragma comment(lib,"avutil.lib")
  
  
  
  #include 
  
  #include 
  
  #include 
  
  #include 
  
  #include <libavutil></libavutil>opt.h>
  
  #include 
  
  #include 
  
  #include 
  
  #include 
  
  #include 
  
  
  
  }
  
  
  
  
  
  using namespace std;
  
  
  
  
  
  void open_video(AVFormatContext*oc , AVCodec *codec, AVStream * st)
  
  {
  
  int ret;
  
  AVCodecContext *c ;
  
  c = st->codec;
  
  
  
  /*open codec */
  
  
  
  cout &lt;&lt; "probably starts here" &lt;&lt; endl;
  
  ret = avcodec_open2(c,codec,NULL);
  
  cout &lt;&lt; "and ends here" &lt;&lt; endl;
  
  
  
  if ( ret &lt; 0)
  
  {
  
      cout &lt;&lt; ("Could not open video codec") &lt;&lt; endl;
  
  }
  
  
  
  
  
  }
  
  
  
  
  
  
  
  
  
  
  
  
  
  /*This function will add a new stream to our file.
  
  @param
  
  oc -> Format context that the new stream will be added.
  
  codec -> codec of the stream, this will be passed.
  
  codec_id -> 
  
  chWidth->
  
  chHeight->
  
  */
  
  
  
  AVStream * addStream(AVFormatContext * oc, AVCodec **codec, enum AVCodecID codec_id, int chWidth,        int chHeight, int fps)
  
  {
  
  AVCodecContext *c;
  
  AVStream *st;
  
  
  
  //find encoder of the stream, it passes this information to @codec, later on
  
  //it will be used in encoding the video @ avcodec_encode_video2 in loop.
  
  *codec = avcodec_find_encoder(AV_CODEC_ID_H264);
  
  
  
  if ( (*codec) == NULL)
  
      cout &lt;&lt; "ERROR CAN NOT FIND ENCODER! ERROR! ERROR! AVCODEC_FIND_ENCODER FAILED !!!1 """ &lt;&lt; endl;
  
  
  
  if(!(*codec))
  
      printf ("Could not find encoder for &#39; %s &#39; ", avcodec_get_name(codec_id));
  
  
  
  
  
  //create a new stream with the found codec inside oc(AVFormatContext).
  
  st = avformat_new_stream ( oc, *codec);
  
  
  
  if (!st)
  
      cout &lt;&lt; " Cannot allocate stream " &lt;&lt; endl;
  
  
  
  //Setting the stream id.
  
  //Since, there can be other streams in this AVFormatContext,
  
  //we should find the first non used index. And this is oc->nb_streams(number of streams) - 1
  
  st ->id = oc ->nb_streams - 1;
  
  
  
  c = st->codec;
  
  
  
  //setting the stream&#39;s codec&#39;s properties.
  
  c-> codec_id = codec_id;
  
  c->bit_rate = 4000000;
  
  c->width = chWidth;
  
  c->height = chHeight;
  
  c->time_base.den = fps;
  
      //fps;
  
  c->time_base.num = 1;
  
  c->gop_size = 12;
  
  c->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
  if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
  
          /* just for testing, we also add B frames */
  
          c->max_b_frames = 2;
  
      }
  
  
  
  
  
  if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
  
          /* Needed to avoid using macroblocks in which some coeffs overflow.
  
           * This does not happen with normal video, it just happens here as
  
           * the motion of the chroma plane does not match the luma plane. */
  
          c->mb_decision = 2;
  
      }
  
  
  
  /* Some formats want stream headers to be separate. */
  
   if (oc->oformat->flags &amp; AVFMT_GLOBALHEADER)
  
      c->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  
  
  //returning our lovely new brand stream.
  
  return st;
  
  
  
  
  
  }
  
  
  
  int changeResolution ( string source, int format )
  
  {
  
  //Data members
  
  struct SwsContext   *sws_ctx = NULL;
  
  AVFrame             *pFrame = NULL;
  
  AVFrame             *outFrame = NULL;   
  
  AVPacket            packet;
  
  uint8_t             *buffer = NULL;
  
  uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
  AVDictionary        *optionsDict = NULL;
  
  AVFormatContext     *pFormatCtx = NULL; 
  
  AVFormatContext     *outputContext = NULL;
  
  AVCodecContext      *pCodecCtx;
  
  AVCodec             *pCodec ;
  
  AVCodec             *codec;
  
  AVCodec             *videoCodec;
  
  AVOutputFormat      *fmt;
  
  AVStream            *video_stream;
  
  int                 changeWidth;
  
  int                  changeHeight;
  
  int                 frameFinished;
  
  int                 numBytes;
  
  int                 fps;
  
  
  
  
  
  int lock = 0;
  
  
  
  //Register all codecs &amp; other important stuff. Vital!..
  
  av_register_all();
  
  
  
  
  
  //Selects the desired resolution.
  
  if (format == 0)
  
  {
  
      changeWidth = 320;
  
      changeHeight = 180;
  
  }
  
  
  
  else if (format == 1)
  
  {
  
      changeWidth = 640;
  
      changeHeight = 480;
  
  
  
  }
  
  else if (format == 2)
  
  {
  
      changeWidth = 960;
  
      changeHeight = 540;
  
  
  
  }
  
  else if (format == 3)
  
  {
  
      changeWidth = 1024;
  
      changeHeight = 768;
  
  
  
  }
  
  else
  
  {
  
      changeWidth = 1280;
  
      changeHeight = 720;
  
  }
  
  
  
  
  
  // Open video file
  
  int aaa;
  
  aaa = avformat_open_input(&amp;pFormatCtx, source.c_str(), NULL, NULL) ;
  
  if(aaa !=0)
  
  {
  
      cout &lt;&lt; " cannot open input file \n" &lt;&lt; endl;
  
      cout &lt;&lt; "aaa = " &lt;&lt; aaa  &lt;&lt; endl;
  
       return -1; // Couldn&#39;t open file   
  
  }
  
  
  
  // Retrieve stream information
  
  if(av_find_stream_info(pFormatCtx)&lt;0)
  
      return -1; // Couldn&#39;t find stream information
  
  
  
  //just checking duration casually for no reason
  
  /*int64_t duration = pFormatCtx->duration;
  
  
  
  cout &lt;&lt; "the duration is " &lt;&lt; duration &lt;&lt; " " &lt;&lt; endl;*/
  
  
  
  //this writes the info about the file
  
  av_dump_format(pFormatCtx, 0, 0, 0);
  
  cin >> lock;
  
  
  
  // Find the first video stream
  
  int videoStream=-1;
  
  int i;
  
  
  
  for(i=0; i&lt;3; i++)
  
       if(pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
  
        videoStream=i;
  
        cout &lt;&lt; " lel \n " ;
  
       break;
  
  
  
   }
  
  
  
  
  
  if(videoStream==-1)
  
      return -1; // Didn&#39;t find a video stream
  
  
  
  // Get a pointer to the codec context for the video stream
  
  pCodecCtx=pFormatCtx->streams[videoStream]->codec;
  
  fps = pCodecCtx -> time_base.den;
  
  
  
  
  
  
  
  //Find the decoder of the input file, for the video stream
  
  pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
  
  
  
  if(pCodec==NULL) {
  
      fprintf(stderr, "Unsupported codec!\n");
  
      return -1; // Codec not found
  
  }
  
  
  
  
  
  // Open codec, you must open it first, in order to use it.
  
  if(avcodec_open2(pCodecCtx, pCodec, &amp;optionsDict)&lt;0)
  
  return -1; // Could not open codec
  
  
  
  
  
  // Allocate video frame ( pFrame for taking the packets into, outFrame for processed frames to packet.)
  
   pFrame=avcodec_alloc_frame();
  
   outFrame = avcodec_alloc_frame();
  
  
  
  
  
  i=0;
  
  
  
  int ret;
  
  int video_frame_count = 0;
  
  
  
  //Initiate the outFrame set the buffer &amp; fill the properties
  
  numBytes=avpicture_get_size(PIX_FMT_YUV420P, changeWidth, changeHeight);
  
  buffer=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
  
      avpicture_fill((AVPicture *)outFrame, buffer, PIX_FMT_YUV420P, changeWidth, changeHeight );  
  
  
  
  
  
  int pp;
  
  int frameNo = 0;
  
  
  
  //allocate the outputContext, it will be the AVFormatContext of our output file. 
  
  //It will try to find the format by giving the file name.
  
  avformat_alloc_output_context2(&amp;outputContext,NULL,NULL, "myoutput.mp4");
  
  
  
  //Cant find the file extension, using MPEG as default.
  
  if (!outputContext) {
  
      printf("Could not deduce output format from file extension: using MPEG.\n");
  
      avformat_alloc_output_context2(&amp;outputContext, NULL, "mpeg", "myoutput.mp4");
  
  }
  
  
  
  //Still cant set file extension, exit.
  
  if (!outputContext) {
  
      return 1;
  
  }
  
  
  
  //set AVOutputFormat fmt to our outputContext&#39;s format.
  
  fmt = outputContext -> oformat;
  
  video_stream = NULL;
  
  
  
  //If fmt has a valid codec_id, create a new video stream.
  
  //This function will set the streams codec &amp; codecs desired properties.
  
  //Stream&#39;s codec will be passed to videoCodec for later usage.
  
  if (fmt -> video_codec != AV_CODEC_ID_NONE)
  
      video_stream = addStream(outputContext, &amp;videoCodec, fmt ->video_codec, changeWidth, changeHeight,fps);
  
  
  
  
  
  //open the video using videoCodec. by avcodec_open2() i.e open the codec.
  
  if (video_stream)   
  
      open_video(outputContext, videoCodec, video_stream);
  
  
  
  //Creating our new output file.
  
  if (!(fmt->flags &amp; AVFMT_NOFILE)) {
  
      ret = avio_open(&amp;outputContext->pb, "toBeStreamed.264", AVIO_FLAG_WRITE);
  
      if (ret &lt; 0) {
  
          cout &lt;&lt; " cant open file " &lt;&lt; endl;
  
          return 1;
  
        }
  
     }
  
  
  
  //Writing the header of format context.
  
  //ret = avformat_write_header(outputContext, NULL);
  
  
  
  if (ret >= 0) {
  
      cout &lt;&lt; "writing header success !!!"  &lt;&lt; endl;
  
  }
  
  
  
  
  
    //Start reading packages from input file.
  
   while(av_read_frame(pFormatCtx, &amp;packet)>=0  ) {
  
  
  
  // Is this a packet from the video stream?  
  
  if(packet.stream_index==videoStream) {
  
  
  
  // Decode video package into frames
  
  ret = avcodec_decode_video2(pCodecCtx, pFrame, &amp;frameFinished, &amp;packet);
  
  
  
  if( ret &lt; 0)
  
  {
  
      printf ( " Error decoding frame !!.." );
  
      return ret;
  
  }
  
  
  
  if (frameFinished){
  
      printf("video_frame n:%d    coded_n:%d\n" , video_frame_count++, pFrame->coded_picture_number);
  
  }
  
  
  
  av_free_packet(&amp;packet);
  
  
  
  //do stuff with frame, in this case we are changing the resolution.
  
  static struct SwsContext *img_convert_ctx_in = NULL;
  
  if (img_convert_ctx_in == NULL)
  
  {
  
      img_convert_ctx_in =sws_getContext( pCodecCtx->width,
  
          pCodecCtx->height, 
  
          pCodecCtx->pix_fmt,
  
          changeWidth,
  
          changeHeight,
  
          PIX_FMT_YUV420P,
  
          SWS_BICUBIC,
  
          NULL,
  
          NULL, 
  
          NULL ); 
  
  
  
  }
  
  //scale the frames
  
  sws_scale(img_convert_ctx_in,
  
      pFrame->data, 
  
      pFrame->linesize,
  
      0, 
  
      pCodecCtx->height, 
  
      outFrame->data,
  
      outFrame->linesize);
  
  
  
  //initiate the pts value
  
  if ( frameNo == 0)
  
      outFrame->pts = 0;
  
  
  
  
  
      //calculate the pts value &amp; set it.
  
      outFrame->pts += av_rescale_q(1, video_stream->codec->time_base, video_stream->time_base);
  
  
  
      //encode frames into packages. Package passed in @packet.
  
      if(avcodec_encode_video2(outputContext->streams[0]->codec, &amp;packet, outFrame, &amp;pp) &lt; 0 )
  
        cout &lt;&lt; "Encoding frames into packages, failed. " &lt;&lt;  endl;
  
  
  
      frameNo++;
  
  
  
      //write the packages into file, resulting in creating a video file.
  
      av_interleaved_write_frame(outputContext,&amp;packet);
  
  
  
  
  
    }
  
  
  
  }
  
  
  
  
  
  
  
  av_free_packet(&amp;packet);
  
  //av_write_trailer(outputContext);
  
  
  
  avio_close(outputContext->pb);
  
  
  
  
  
  
  
   // Free the RGB image
  
   av_free(buffer);
  
   av_free(outFrame);
  
  
  
   // Free the YUV frame
  
   av_free(pFrame);
  
  
  
  // Close the codec
  
  avcodec_close(video_stream->codec);
  
  avcodec_close(pCodecCtx);
  
  
  
  // Close the video file
  
  avformat_close_input(&amp;pFormatCtx);
  
  
  
  return 0;
  
  
  
  
  
  }
  
  </iostream>

  at the end of the process I get my desired file with desired codec & container & resolution.

  My problem is, in a part of our project I need to get elementary video streams IN file. Such as example.264. However I can not add a stream without creating an AVFormatContext. I can not create an AVFormatContext because 264 files does not have a container,they are just raw video ?, as far as I know.

  I have tried the way in decoding_encoding.c which uses fwrite. However that example was for mpeg-2 codec and when I try to adapt that code to H264/AVC codec, I got "floating point division by zero" error from mediainfo and moreover, some of the properties of the video was not showing (such as FPS & playtime & quality factor). I think it has to do with the "endcode" the example adds at the end of the code. It is for mpeg-2. ( uint8_t endcode[] = 0, 0, 1, 0xb7  ; )

  Anyway, I would love to get a startpoint for this task. I have managed to come this far by using internet resources ( quite few & outdated for ffmpeg) but now I'm stuck a little.