C / C++ / MFC

int main(int argc, char **argv)
{
    const char *filename;
    AVOutputFormat *fmt;
    AVFormatContext *oc;
	AVFormatContext *ic;
	AVCodecContext *pCodecCtx;
	AVCodec *pCodec;
    AVStream *audio_st, *video_st;
	int i,frame,video_stream;

    // initialize libavcodec, and register all codecs and formats 
    av_register_all();    
     
    filename = "test.mp4";

	if(av_open_input_file(&ic, filename, NULL, 0, NULL)!=0) 
		return -1;	// Couldn't open file 

	// Retrieve stream information
	if(av_find_stream_info(ic)<0) 
		return -1; // Couldn't find stream information 

	// Find the first video stream 
	video_stream=-1; 
	for(i=0; i<10; i++) 
	if(ic->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO) 
	{ 
		video_stream=i; 
		break; 
	}
	if(video_stream==-1) 
		return -1; // Didn't find a video stream 

	// Get a pointer to the codec context for the video stream 
	pCodecCtx=ic->streams[video_stream]->codec; 

	// Find the decoder for the video stream 
	pCodec=avcodec_find_decoder(pCodecCtx->codec_id); 
	if(pCodec==NULL) return -1; // Codec not found 

	// Open codec 
	if(avcodec_open(pCodecCtx, pCodec)<0) return -1; // Could not open codec 

	// Allocate frames
    AVPacket    pkt;
    AVFrame videoFrame;

	// auto detect the output format from the name. default is mpeg. 
    fmt = guess_format(NULL, filename, NULL);
    if (!fmt) {
        printf("Could not deduce output format from file extension: using MPEG.\n");
        fmt = guess_format("mpeg", NULL, NULL);
    }
    if (!fmt) {
        fprintf(stderr, "Could not find suitable output format\n");
        exit(1);
    }

	/* allocate the output media context */
    oc = av_alloc_format_context();
    if (!oc) {
        fprintf(stderr, "Memory error\n");
        exit(1);
    }
    oc->oformat = fmt;
    _snprintf(oc->filename, sizeof(oc->filename), "%s", filename);

	// Add video stream
    AVStream* stream = av_new_stream(oc, 0);
    AVCodecContext* videoEncoderContext = stream->codec;
    setupVideoEncode(videoEncoderContext);
    stream->sample_aspect_ratio = av_d2q(1, 255);
    stream->pts_wrap_bits = 33;
    stream->codec->thread_count = 0;

	// Set output parameters
    if (av_set_parameters(oc, 0) < 0) {
        return 0;
    }   
    // Open video encoder
    
    AVCodec* codec = avcodec_find_encoder(videoEncoderContext->codec_id);
    if (!codec)
	{        
        return 0;
	}

    if (avcodec_open(videoEncoderContext, codec) < 0)
    {
        return 0;
    }    /* write the stream header, if any */
    av_write_header(oc);

	 /* open the output file, if needed */
	const char *ofilename = "testresult.mp4";
    if (!(fmt->flags & AVFMT_NOFILE)) {
        if (url_fopen(&oc->pb, ofilename, URL_WRONLY) < 0) {
            fprintf(stderr, "Could not open '%s'\n", filename);
            exit(1);
        }
    }
	// Do the transcoding
    int audioFrameFinished = 0;
    int videoFrameFinished = 0; 
	const int outbuf_size = 640000;
    uint8_t outbuf[outbuf_size];
    int64_t lastpts = 0;

	while(av_read_frame( ic, &pkt ) == 0)
    {
		if (video_stream == pkt.stream_index)
		{
            avcodec_get_frame_defaults(&videoFrame);
            avcodec_decode_video(pCodecCtx, &videoFrame,&videoFrameFinished,pkt.data, pkt.size);
            videoFrame.pts = pkt.dts;
            if (videoFrameFinished)
            {
                int out_size = avcodec_encode_video(videoEncoderContext,outbuf, outbuf_size, &videoFrame);                if (out_size > 0)
                {
                    AVPacket outpkt;
                    av_init_packet(&outpkt);
                    outpkt.data = outbuf;
                    outpkt.size = out_size;
                    outpkt.stream_index = 0;
                    outpkt.dts = outpkt.pts = videoEncoderContext->coded_frame->pts;
                    outpkt.flags |=(videoEncoderContext->coded_frame->key_frame) ? PKT_FLAG_KEY : 0;               
                   
                    if (av_write_frame (oc, &outpkt) < 0)
                    {
                       return 0;
                    }
                }
            }
        }
        av_free_packet( &pkt );
    }
    
    /* write the trailer, if any */
    av_write_trailer(oc);

	avcodec_close(videoEncoderContext);
    av_free(videoEncoderContext);
 
    /* free the streams */
    for(i = 0; i < oc->nb_streams; i++) {
        av_freep(&oc->streams[i]);
    }

    if (!(fmt->flags & AVFMT_NOFILE)) {
        /* close the output file */
        url_fclose(oc->pb);
    }

    /* free the stream */
    av_free(oc);

    return 0;
}

//inherit/geogroup.hpp

#ifndef GEOGROUP_HPP
#define GEOGROUP_HPP

//include header file for the base class
#include "geo.hpp"

//header for the internal management of the elements
#include <vector>

namespace Geo
{
	/*class GeoGroup
	 *	-derived from GeoObj
	 *	-a GeoGroup Consists of
	 *		-A reference point (inherited)
	 *		-A collection of geometric elements (new)
	 */
	Class GeoGroup : public GeoObj
	{
	protected:
		std::vector<GeoObj*> elems;		//collection of pointers to GeoObjs

	public:
		//constructor with optional reference point
		GeoGroup(const Coord& p = Coord(0,0)) : GeoObj(p)
		{
		}

		//output (now also implemented)
		virtual void draw() const;

		//insert element
		virtual void add(GeoObj&);

		//remove element
		virtual bool remove(GeoObj&);

		//virtual destructor
		virtual ~GeoGroup()
		{
		}
	};

}//*****END namespace GeoGroup*****

#endif		//GEOGROUP_HPP

//inherit/geogroup.cpp

//include header class
#include "geogroup.hpp"

//header for algorithms
#include <algorithm>

namespace Geo
{
	/*add
	 *	-insert elements
	 */
	void GeoGroup::draw() const
	{
		for (unsigned i = 0 ; i < elems.size(); ++i)
		{
			elems[i]->move(refpoint);		//add offset for the reference point
			elems[i]->draw();				//draw element
			elems[i]->move(-refpoint);		//subtract offset
		}
	}

	/*remove
	 *	- delete element
	 */
	bool GeoGroup::remove(GeoObj& obj)
	{
		//find first element with this address and remove it
		//return whether an object was found and removed
		std::vector<GeoObj*>::iterator pos;
		pos = std::find(elems.begin(), elems.end(), &obj);
		if (pos != elems.end())
		{
			elems.erase(pos);
			return true;
		}
		else
		{
			return false;
		}
	}
}