Merge commit 'b339182eba34f28de5f1a477cdd2c84f1ef35d90'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 17 Feb 2014 00:48:42 +0000 (01:48 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 17 Feb 2014 01:22:01 +0000 (02:22 +0100)
* commit 'b339182eba34f28de5f1a477cdd2c84f1ef35d90':
  Move all example programs to doc/examples

Conflicts:
configure
doc/Makefile
doc/doxy-wrapper.sh
doc/examples/avcodec.c
doc/examples/decoding_encoding.c
doc/examples/metadata.c
doc/examples/muxing.c
doc/examples/transcode_aac.c
libavcodec/Makefile
libavcodec/api-example.c
libavformat/Makefile

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
.gitignore
common.mak
configure
doc/Makefile
doc/doxy-wrapper.sh
doc/examples/Makefile
doc/examples/avcodec.c
doc/examples/transcode_aac.c
libavformat/Makefile
library.mak

diff --cc .gitignore
  *.ver
  *-example
  *-test
 +*_g
  /.config
  /.version
 -/avconv
 -/avplay
 -/avprobe
 -/avserver
 +/ffmpeg
 +/ffplay
 +/ffprobe
 +/ffserver
  /config.*
  /coverage.info
 -/version.h
  /doc/*.1
 +/doc/*.3
  /doc/*.html
  /doc/*.pod
 +/doc/config.texi
  /doc/avoptions_codec.texi
  /doc/avoptions_format.texi
- /doc/examples/decoding_encoding
 +/doc/examples/avio_reading
++/doc/examples/avcodec
 +/doc/examples/demuxing_decoding
 +/doc/examples/filtering_audio
 +/doc/examples/filtering_video
 +/doc/examples/metadata
 +/doc/examples/muxing
 +/doc/examples/pc-uninstalled
 +/doc/examples/remuxing
 +/doc/examples/resampling_audio
 +/doc/examples/scaling_video
 +/doc/examples/transcode_aac
 +/doc/fate.txt
  /doc/doxy/html/
  /doc/examples/output
  /doc/examples/transcode_aac
diff --cc common.mak
@@@ -96,9 -14,7 +96,8 @@@ TESTPROGS += $(TESTPROGS-yes
  LDLIBS       = $(FFLIBS:%=%$(BUILDSUF))
  FFEXTRALIBS := $(LDLIBS:%=$(LD_LIB)) $(EXTRALIBS)
  
- EXAMPLES  := $(EXAMPLES:%=$(SUBDIR)%-example$(EXESUF))
  OBJS      := $(sort $(OBJS:%=$(SUBDIR)%))
 +SLIBOBJS  := $(sort $(SLIBOBJS:%=$(SUBDIR)%))
  TESTOBJS  := $(TESTOBJS:%=$(SUBDIR)%) $(TESTPROGS:%=$(SUBDIR)%-test.o)
  TESTPROGS := $(TESTPROGS:%=$(SUBDIR)%-test$(EXESUF))
  HOSTOBJS  := $(HOSTPROGS:%=$(SUBDIR)%.o)
diff --cc configure
+++ b/configure
@@@ -1244,16 -1095,9 +1244,16 @@@ COMPONENT_LIST=
  "
  
  EXAMPLE_LIST="
-     decoding_encoding_example
 +    avio_reading_example
+     avcodec_example
 +    demuxing_decoding_example
 +    filtering_audio_example
 +    filtering_video_example
      metadata_example
 -    output_example
 +    muxing_example
 +    remuxing_example
 +    resampling_audio_example
 +    scaling_video_example
      transcode_aac_example
  "
  
@@@ -2338,81 -2006,26 +2338,81 @@@ unix_protocol_deps="sys_un_h
  unix_protocol_select="network"
  
  # filters
 +aconvert_filter_deps="swresample"
 +amovie_filter_deps="avcodec avformat"
 +aresample_filter_deps="swresample"
 +ass_filter_deps="libass"
 +asyncts_filter_deps="avresample"
 +atempo_filter_deps="avcodec"
 +atempo_filter_select="rdft"
 +azmq_filter_deps="libzmq"
  blackframe_filter_deps="gpl"
  boxblur_filter_deps="gpl"
 +colormatrix_filter_deps="gpl"
  cropdetect_filter_deps="gpl"
 +dctdnoiz_filter_deps="avcodec"
 +dctdnoiz_filter_select="fft"
  delogo_filter_deps="gpl"
 +deshake_filter_deps="avcodec"
 +deshake_filter_select="dsputil"
  drawtext_filter_deps="libfreetype"
 -frei0r_filter_deps="frei0r dlopen strtok_r"
 +ebur128_filter_deps="gpl"
 +flite_filter_deps="libflite"
 +frei0r_filter_deps="frei0r dlopen"
  frei0r_filter_extralibs='$ldl'
 -frei0r_src_filter_deps="frei0r dlopen strtok_r"
 +frei0r_src_filter_deps="frei0r dlopen"
  frei0r_src_filter_extralibs='$ldl'
 +geq_filter_deps="gpl"
 +histeq_filter_deps="gpl"
  hqdn3d_filter_deps="gpl"
  interlace_filter_deps="gpl"
 +kerndeint_filter_deps="gpl"
 +ladspa_filter_deps="ladspa dlopen"
 +mcdeint_filter_deps="avcodec gpl"
 +movie_filter_deps="avcodec avformat"
 +mp_filter_deps="gpl avcodec swscale inline_asm"
 +mpdecimate_filter_deps="gpl avcodec"
 +mptestsrc_filter_deps="gpl"
 +negate_filter_deps="lut_filter"
 +perspective_filter_deps="gpl"
  resample_filter_deps="avresample"
  ocv_filter_deps="libopencv"
 +owdenoise_filter_deps="gpl"
 +pan_filter_deps="swresample"
 +phase_filter_deps="gpl"
 +pp_filter_deps="gpl postproc"
 +pullup_filter_deps="gpl"
 +removelogo_filter_deps="avcodec avformat swscale"
 +sab_filter_deps="gpl swscale"
  scale_filter_deps="swscale"
 +smartblur_filter_deps="gpl swscale"
 +showspectrum_filter_deps="avcodec"
 +showspectrum_filter_select="rdft"
 +spp_filter_deps="gpl avcodec"
 +spp_filter_select="fft"
 +stereo3d_filter_deps="gpl"
 +subtitles_filter_deps="avformat avcodec libass"
 +super2xsai_filter_deps="gpl"
 +tinterlace_filter_deps="gpl"
 +vidstabdetect_filter_deps="libvidstab"
 +vidstabtransform_filter_deps="libvidstab"
 +pixfmts_super2xsai_test_deps="super2xsai_filter"
 +tinterlace_merge_test_deps="tinterlace_filter"
 +tinterlace_pad_test_deps="tinterlace_filter"
 +zmq_filter_deps="libzmq"
  
  # examples
- decoding_encoding_example_deps="avcodec avutil"
 +avio_reading="avformat avcodec avutil"
+ avcodec_example_deps="avcodec avutil"
 +demuxing_decoding_example_deps="avcodec avformat avutil"
 +filtering_audio_example_deps="avfilter avcodec avformat avutil"
 +filtering_video_example_deps="avfilter avcodec avformat avutil"
  metadata_example_deps="avformat avutil"
 -output_example_deps="avcodec avformat avutil swscale"
 -transcode_aac_example_deps="avcodec avformat avresample"
 +muxing_example_deps="avcodec avformat avutil swscale"
 +remuxing_example_deps="avcodec avformat avutil"
 +resampling_audio_example_deps="avutil swresample"
 +scaling_video_example_deps="avutil swscale"
 +transcode_aac_example_deps="avcodec avformat swresample"
  
  # libraries
  avcodec_deps="avutil"
diff --cc doc/Makefile
@@@ -27,36 -10,22 +27,36 @@@ HTMLPAGES   = $(AVPROGS-yes:%=doc/%.htm
                doc/nut.html                                              \
                doc/platform.html                                         \
  
 -DOCS-$(CONFIG_POD2MAN)                          += $(MANPAGES) $(PODPAGES)
 -DOCS-$(CONFIG_TEXI2HTML)                        += $(HTMLPAGES)
 +TXTPAGES    = doc/fate.txt                                              \
 +
 +
 +DOCS-$(CONFIG_HTMLPAGES) += $(HTMLPAGES)
 +DOCS-$(CONFIG_PODPAGES)  += $(PODPAGES)
 +DOCS-$(CONFIG_MANPAGES)  += $(MANPAGES)
 +DOCS-$(CONFIG_TXTPAGES)  += $(TXTPAGES)
  DOCS = $(DOCS-yes)
  
 -DOC_EXAMPLES-$(CONFIG_AVCODEC_EXAMPLE)          += avcodec
 -DOC_EXAMPLES-$(CONFIG_METADATA_EXAMPLE)         += metadata
 -DOC_EXAMPLES-$(CONFIG_OUTPUT_EXAMPLE)           += output
 -DOC_EXAMPLES-$(CONFIG_TRANSCODE_AAC_EXAMPLE)    += transcode_aac
 -ALL_DOC_EXAMPLES = avcodec metadata output transcode_aac
 +DOC_EXAMPLES-$(CONFIG_AVIO_READING_EXAMPLE)      += avio_reading
- DOC_EXAMPLES-$(CONFIG_DECODING_ENCODING_EXAMPLE) += decoding_encoding
++DOC_EXAMPLES-$(CONFIG_AVCODEC_EXAMPLE)           += avcodec
 +DOC_EXAMPLES-$(CONFIG_DEMUXING_DECODING_EXAMPLE) += demuxing_decoding
 +DOC_EXAMPLES-$(CONFIG_FILTERING_AUDIO_EXAMPLE)   += filtering_audio
 +DOC_EXAMPLES-$(CONFIG_FILTERING_VIDEO_EXAMPLE)   += filtering_video
 +DOC_EXAMPLES-$(CONFIG_METADATA_EXAMPLE)          += metadata
 +DOC_EXAMPLES-$(CONFIG_MUXING_EXAMPLE)            += muxing
 +DOC_EXAMPLES-$(CONFIG_REMUXING_EXAMPLE)          += remuxing
 +DOC_EXAMPLES-$(CONFIG_RESAMPLING_AUDIO_EXAMPLE)  += resampling_audio
 +DOC_EXAMPLES-$(CONFIG_SCALING_VIDEO_EXAMPLE)     += scaling_video
 +DOC_EXAMPLES-$(CONFIG_TRANSCODE_AAC_EXAMPLE)     += transcode_aac
 +ALL_DOC_EXAMPLES_LIST = $(DOC_EXAMPLES-) $(DOC_EXAMPLES-yes)
 +
 +DOC_EXAMPLES       := $(DOC_EXAMPLES-yes:%=doc/examples/%$(PROGSSUF)$(EXESUF))
 +ALL_DOC_EXAMPLES   := $(ALL_DOC_EXAMPLES_LIST:%=doc/examples/%$(PROGSSUF)$(EXESUF))
 +ALL_DOC_EXAMPLES_G := $(ALL_DOC_EXAMPLES_LIST:%=doc/examples/%$(PROGSSUF)_g$(EXESUF))
 +PROGS              += $(DOC_EXAMPLES)
  
 -DOC_EXAMPLES     := $(DOC_EXAMPLES-yes:%=doc/examples/%$(EXESUF))
 -ALL_DOC_EXAMPLES := $(ALL_DOC_EXAMPLES:%=doc/examples/%$(EXESUF))
 -PROGS            += $(DOC_EXAMPLES)
 +all-$(CONFIG_DOC): doc
  
 -all: $(DOCS)
 +doc: documentation
  
  apidoc: doc/doxy/html
  documentation: $(DOCS)
@@@ -8,5 -8,8 +8,5 @@@ shift 
  doxygen - <<EOF
  @INCLUDE        = ${DOXYFILE}
  INPUT           = $@
- EXAMPLE_PATH    = ${SRC_PATH}/
+ EXAMPLE_PATH    = ${SRC_PATH}/doc/examples
 -HTML_HEADER     = ${SRC_PATH}/doc/doxy/header.html
 -HTML_FOOTER     = ${SRC_PATH}/doc/doxy/footer.html
 -HTML_STYLESHEET = ${SRC_PATH}/doc/doxy/doxy_stylesheet.css
  EOF
index f4f6c70,0000000..1553bab
mode 100644,000000..100644
--- /dev/null
@@@ -1,41 -1,0 +1,41 @@@
-                 decoding_encoding                  \
 +# use pkg-config for getting CFLAGS and LDLIBS
 +FFMPEG_LIBS=    libavdevice                        \
 +                libavformat                        \
 +                libavfilter                        \
 +                libavcodec                         \
 +                libswresample                      \
 +                libswscale                         \
 +                libavutil                          \
 +
 +CFLAGS += -Wall -g
 +CFLAGS := $(shell pkg-config --cflags $(FFMPEG_LIBS)) $(CFLAGS)
 +LDLIBS := $(shell pkg-config --libs $(FFMPEG_LIBS)) $(LDLIBS)
 +
 +EXAMPLES=       avio_reading                       \
- decoding_encoding: LDLIBS += -lm
++                avcodec                            \
 +                demuxing_decoding                  \
 +                filtering_video                    \
 +                filtering_audio                    \
 +                metadata                           \
 +                muxing                             \
 +                remuxing                           \
 +                resampling_audio                   \
 +                scaling_video                      \
 +                transcode_aac                      \
 +
 +OBJS=$(addsuffix .o,$(EXAMPLES))
 +
 +# the following examples make explicit use of the math library
++avcodec:           LDLIBS += -lm
 +muxing:            LDLIBS += -lm
 +resampling_audio:  LDLIBS += -lm
 +
 +.phony: all clean-test clean
 +
 +all: $(OBJS) $(EXAMPLES)
 +
 +clean-test:
 +      $(RM) test*.pgm test.h264 test.mp2 test.sw test.mpg
 +
 +clean: clean-test
 +      $(RM) $(EXAMPLES) $(OBJS)
index 0000000,1478881..d56e6a4
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,595 +1,658 @@@
 - * copyright (c) 2001 Fabrice Bellard
+ /*
 - * This file is part of Libav.
++ * Copyright (c) 2001 Fabrice Bellard
+  *
 - * 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.
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to deal
++ * in the Software without restriction, including without limitation the rights
++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++ * copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
+  *
 - * 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
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
+  *
 - * Note that this library only handles codecs (mpeg, mpeg4, etc...),
 - * not file formats (avi, vob, etc...). See library 'libavformat' for the
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++ * THE SOFTWARE.
+  */
+ /**
+  * @file
+  * libavcodec API use example.
+  *
+  * @example avcodec.c
 -#include <stdlib.h>
 -#include <stdio.h>
 -#include <string.h>
 -
 -#ifdef HAVE_AV_CONFIG_H
 -#undef HAVE_AV_CONFIG_H
 -#endif
++ * Note that libavcodec only handles codecs (mpeg, mpeg4, etc...),
++ * not file formats (avi, vob, mp4, mov, mkv, mxf, flv, mpegts, mpegps, etc...). See library 'libavformat' for the
+  * format handling
+  */
 -#include "libavcodec/avcodec.h"
 -#include "libavutil/channel_layout.h"
 -#include "libavutil/common.h"
 -#include "libavutil/imgutils.h"
 -#include "libavutil/mathematics.h"
 -#include "libavutil/samplefmt.h"
++#include <math.h>
 -    printf("Audio encoding\n");
++#include <libavutil/opt.h>
++#include <libavcodec/avcodec.h>
++#include <libavutil/channel_layout.h>
++#include <libavutil/common.h>
++#include <libavutil/imgutils.h>
++#include <libavutil/mathematics.h>
++#include <libavutil/samplefmt.h>
+ #define INBUF_SIZE 4096
+ #define AUDIO_INBUF_SIZE 20480
+ #define AUDIO_REFILL_THRESH 4096
+ /* check that a given sample format is supported by the encoder */
+ static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
+ {
+     const enum AVSampleFormat *p = codec->sample_fmts;
+     while (*p != AV_SAMPLE_FMT_NONE) {
+         if (*p == sample_fmt)
+             return 1;
+         p++;
+     }
+     return 0;
+ }
+ /* just pick the highest supported samplerate */
+ static int select_sample_rate(AVCodec *codec)
+ {
+     const int *p;
+     int best_samplerate = 0;
+     if (!codec->supported_samplerates)
+         return 44100;
+     p = codec->supported_samplerates;
+     while (*p) {
+         best_samplerate = FFMAX(*p, best_samplerate);
+         p++;
+     }
+     return best_samplerate;
+ }
+ /* select layout with the highest channel count */
+ static int select_channel_layout(AVCodec *codec)
+ {
+     const uint64_t *p;
+     uint64_t best_ch_layout = 0;
+     int best_nb_channels   = 0;
+     if (!codec->channel_layouts)
+         return AV_CH_LAYOUT_STEREO;
+     p = codec->channel_layouts;
+     while (*p) {
+         int nb_channels = av_get_channel_layout_nb_channels(*p);
+         if (nb_channels > best_nb_channels) {
+             best_ch_layout    = *p;
+             best_nb_channels = nb_channels;
+         }
+         p++;
+     }
+     return best_ch_layout;
+ }
+ /*
+  * Audio encoding example
+  */
+ static void audio_encode_example(const char *filename)
+ {
+     AVCodec *codec;
+     AVCodecContext *c= NULL;
+     AVFrame *frame;
+     AVPacket pkt;
+     int i, j, k, ret, got_output;
+     int buffer_size;
+     FILE *f;
+     uint16_t *samples;
+     float t, tincr;
 -        fprintf(stderr, "codec not found\n");
++    printf("Encode audio file %s\n", filename);
+     /* find the MP2 encoder */
+     codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
+     if (!codec) {
 -        fprintf(stderr, "encoder does not support %s",
++        fprintf(stderr, "Codec not found\n");
+         exit(1);
+     }
+     c = avcodec_alloc_context3(codec);
++    if (!c) {
++        fprintf(stderr, "Could not allocate audio codec context\n");
++        exit(1);
++    }
+     /* put sample parameters */
+     c->bit_rate = 64000;
+     /* check that the encoder supports s16 pcm input */
+     c->sample_fmt = AV_SAMPLE_FMT_S16;
+     if (!check_sample_fmt(codec, c->sample_fmt)) {
 -        fprintf(stderr, "could not open codec\n");
++        fprintf(stderr, "Encoder does not support sample format %s",
+                 av_get_sample_fmt_name(c->sample_fmt));
+         exit(1);
+     }
+     /* select other audio parameters supported by the encoder */
+     c->sample_rate    = select_sample_rate(codec);
+     c->channel_layout = select_channel_layout(codec);
+     c->channels       = av_get_channel_layout_nb_channels(c->channel_layout);
+     /* open it */
+     if (avcodec_open2(c, codec, NULL) < 0) {
 -        fprintf(stderr, "could not open %s\n", filename);
++        fprintf(stderr, "Could not open codec\n");
+         exit(1);
+     }
+     f = fopen(filename, "wb");
+     if (!f) {
 -        fprintf(stderr, "could not allocate audio frame\n");
++        fprintf(stderr, "Could not open %s\n", filename);
+         exit(1);
+     }
+     /* frame containing input raw audio */
+     frame = av_frame_alloc();
+     if (!frame) {
 -        fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
++        fprintf(stderr, "Could not allocate audio frame\n");
+         exit(1);
+     }
+     frame->nb_samples     = c->frame_size;
+     frame->format         = c->sample_fmt;
+     frame->channel_layout = c->channel_layout;
+     /* the codec gives us the frame size, in samples,
+      * we calculate the size of the samples buffer in bytes */
+     buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
+                                              c->sample_fmt, 0);
++    if (buffer_size < 0) {
++        fprintf(stderr, "Could not get sample buffer size\n");
++        exit(1);
++    }
+     samples = av_malloc(buffer_size);
+     if (!samples) {
 -        fprintf(stderr, "could not setup audio frame\n");
++        fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
+                 buffer_size);
+         exit(1);
+     }
+     /* setup the data pointers in the AVFrame */
+     ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
+                                    (const uint8_t*)samples, buffer_size, 0);
+     if (ret < 0) {
 -    for(i=0;i<200;i++) {
++        fprintf(stderr, "Could not setup audio frame\n");
+         exit(1);
+     }
+     /* encode a single tone sound */
+     t = 0;
+     tincr = 2 * M_PI * 440.0 / c->sample_rate;
 -            fprintf(stderr, "error encoding audio frame\n");
++    for (i = 0; i < 200; i++) {
+         av_init_packet(&pkt);
+         pkt.data = NULL; // packet data will be allocated by the encoder
+         pkt.size = 0;
+         for (j = 0; j < c->frame_size; j++) {
+             samples[2*j] = (int)(sin(t) * 10000);
+             for (k = 1; k < c->channels; k++)
+                 samples[2*j + k] = samples[2*j];
+             t += tincr;
+         }
+         /* encode the samples */
+         ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
+         if (ret < 0) {
 -    printf("Audio decoding\n");
++            fprintf(stderr, "Error encoding audio frame\n");
++            exit(1);
++        }
++        if (got_output) {
++            fwrite(pkt.data, 1, pkt.size, f);
++            av_free_packet(&pkt);
++        }
++    }
++
++    /* get the delayed frames */
++    for (got_output = 1; got_output; i++) {
++        ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
++        if (ret < 0) {
++            fprintf(stderr, "Error encoding frame\n");
+             exit(1);
+         }
++
+         if (got_output) {
+             fwrite(pkt.data, 1, pkt.size, f);
+             av_free_packet(&pkt);
+         }
+     }
+     fclose(f);
+     av_freep(&samples);
+     av_frame_free(&frame);
+     avcodec_close(c);
+     av_free(c);
+ }
+ /*
+  * Audio decoding.
+  */
+ static void audio_decode_example(const char *outfilename, const char *filename)
+ {
+     AVCodec *codec;
+     AVCodecContext *c= NULL;
+     int len;
+     FILE *f, *outfile;
+     uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
+     AVPacket avpkt;
+     AVFrame *decoded_frame = NULL;
+     av_init_packet(&avpkt);
 -        fprintf(stderr, "codec not found\n");
++    printf("Decode audio file %s to %s\n", filename, outfilename);
+     /* find the mpeg audio decoder */
+     codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
+     if (!codec) {
 -        fprintf(stderr, "could not open codec\n");
++        fprintf(stderr, "Codec not found\n");
+         exit(1);
+     }
+     c = avcodec_alloc_context3(codec);
++    if (!c) {
++        fprintf(stderr, "Could not allocate audio codec context\n");
++        exit(1);
++    }
+     /* open it */
+     if (avcodec_open2(c, codec, NULL) < 0) {
 -        fprintf(stderr, "could not open %s\n", filename);
++        fprintf(stderr, "Could not open codec\n");
+         exit(1);
+     }
+     f = fopen(filename, "rb");
+     if (!f) {
 -                fprintf(stderr, "out of memory\n");
++        fprintf(stderr, "Could not open %s\n", filename);
+         exit(1);
+     }
+     outfile = fopen(outfilename, "wb");
+     if (!outfile) {
+         av_free(c);
+         exit(1);
+     }
+     /* decode until eof */
+     avpkt.data = inbuf;
+     avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
+     while (avpkt.size > 0) {
+         int got_frame = 0;
+         if (!decoded_frame) {
+             if (!(decoded_frame = av_frame_alloc())) {
 -static void video_encode_example(const char *filename)
++                fprintf(stderr, "Could not allocate audio frame\n");
+                 exit(1);
+             }
+         }
+         len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
+         if (len < 0) {
+             fprintf(stderr, "Error while decoding\n");
+             exit(1);
+         }
+         if (got_frame) {
+             /* if a frame has been decoded, output it */
+             int data_size = av_samples_get_buffer_size(NULL, c->channels,
+                                                        decoded_frame->nb_samples,
+                                                        c->sample_fmt, 1);
++            if (data_size < 0) {
++                /* This should not occur, checking just for paranoia */
++                fprintf(stderr, "Failed to calculate data size\n");
++                exit(1);
++            }
+             fwrite(decoded_frame->data[0], 1, data_size, outfile);
+         }
+         avpkt.size -= len;
+         avpkt.data += len;
++        avpkt.dts =
++        avpkt.pts = AV_NOPTS_VALUE;
+         if (avpkt.size < AUDIO_REFILL_THRESH) {
+             /* Refill the input buffer, to avoid trying to decode
+              * incomplete frames. Instead of this, one could also use
+              * a parser, or use a proper container format through
+              * libavformat. */
+             memmove(inbuf, avpkt.data, avpkt.size);
+             avpkt.data = inbuf;
+             len = fread(avpkt.data + avpkt.size, 1,
+                         AUDIO_INBUF_SIZE - avpkt.size, f);
+             if (len > 0)
+                 avpkt.size += len;
+         }
+     }
+     fclose(outfile);
+     fclose(f);
+     avcodec_close(c);
+     av_free(c);
+     av_frame_free(&decoded_frame);
+ }
+ /*
+  * Video encoding example
+  */
 -    AVFrame *picture;
++static void video_encode_example(const char *filename, int codec_id)
+ {
+     AVCodec *codec;
+     AVCodecContext *c= NULL;
+     int i, ret, x, y, got_output;
+     FILE *f;
 -    printf("Video encoding\n");
++    AVFrame *frame;
+     AVPacket pkt;
+     uint8_t endcode[] = { 0, 0, 1, 0xb7 };
 -    codec = avcodec_find_encoder(AV_CODEC_ID_MPEG1VIDEO);
++    printf("Encode video file %s\n", filename);
+     /* find the mpeg1 video encoder */
 -        fprintf(stderr, "codec not found\n");
++    codec = avcodec_find_encoder(codec_id);
+     if (!codec) {
 -    picture = av_frame_alloc();
++        fprintf(stderr, "Codec not found\n");
+         exit(1);
+     }
+     c = avcodec_alloc_context3(codec);
 -    c->time_base= (AVRational){1,25};
++    if (!c) {
++        fprintf(stderr, "Could not allocate video codec context\n");
++        exit(1);
++    }
+     /* put sample parameters */
+     c->bit_rate = 400000;
+     /* resolution must be a multiple of two */
+     c->width = 352;
+     c->height = 288;
+     /* frames per second */
 -    c->max_b_frames=1;
++    c->time_base = (AVRational){1,25};
+     c->gop_size = 10; /* emit one intra frame every ten frames */
 -        fprintf(stderr, "could not open codec\n");
++    c->max_b_frames = 1;
+     c->pix_fmt = AV_PIX_FMT_YUV420P;
++    if (codec_id == AV_CODEC_ID_H264)
++        av_opt_set(c->priv_data, "preset", "slow", 0);
++
+     /* open it */
+     if (avcodec_open2(c, codec, NULL) < 0) {
 -        fprintf(stderr, "could not open %s\n", filename);
++        fprintf(stderr, "Could not open codec\n");
+         exit(1);
+     }
+     f = fopen(filename, "wb");
+     if (!f) {
 -    ret = av_image_alloc(picture->data, picture->linesize, c->width, c->height,
++        fprintf(stderr, "Could not open %s\n", filename);
++        exit(1);
++    }
++
++    frame = av_frame_alloc();
++    if (!frame) {
++        fprintf(stderr, "Could not allocate video frame\n");
+         exit(1);
+     }
++    frame->format = c->pix_fmt;
++    frame->width  = c->width;
++    frame->height = c->height;
 -        fprintf(stderr, "could not alloc raw picture buffer\n");
++    /* the image can be allocated by any means and av_image_alloc() is
++     * just the most convenient way if av_malloc() is to be used */
++    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
+                          c->pix_fmt, 32);
+     if (ret < 0) {
 -    picture->format = c->pix_fmt;
 -    picture->width  = c->width;
 -    picture->height = c->height;
++        fprintf(stderr, "Could not allocate raw picture buffer\n");
+         exit(1);
+     }
 -    for(i=0;i<25;i++) {
+     /* encode 1 second of video */
 -        for(y=0;y<c->height;y++) {
 -            for(x=0;x<c->width;x++) {
 -                picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
++    for (i = 0; i < 25; i++) {
+         av_init_packet(&pkt);
+         pkt.data = NULL;    // packet data will be allocated by the encoder
+         pkt.size = 0;
+         fflush(stdout);
+         /* prepare a dummy image */
+         /* Y */
 -        for(y=0;y<c->height/2;y++) {
 -            for(x=0;x<c->width/2;x++) {
 -                picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
 -                picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
++        for (y = 0; y < c->height; y++) {
++            for (x = 0; x < c->width; x++) {
++                frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
+             }
+         }
+         /* Cb and Cr */
 -        picture->pts = i;
++        for (y = 0; y < c->height/2; y++) {
++            for (x = 0; x < c->width/2; x++) {
++                frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
++                frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
+             }
+         }
 -        ret = avcodec_encode_video2(c, &pkt, picture, &got_output);
++        frame->pts = i;
+         /* encode the image */
 -            fprintf(stderr, "error encoding frame\n");
++        ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
+         if (ret < 0) {
 -            printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
++            fprintf(stderr, "Error encoding frame\n");
+             exit(1);
+         }
+         if (got_output) {
 -            fprintf(stderr, "error encoding frame\n");
++            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
+             fwrite(pkt.data, 1, pkt.size, f);
+             av_free_packet(&pkt);
+         }
+     }
+     /* get the delayed frames */
+     for (got_output = 1; got_output; i++) {
+         fflush(stdout);
+         ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
+         if (ret < 0) {
 -            printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
++            fprintf(stderr, "Error encoding frame\n");
+             exit(1);
+         }
+         if (got_output) {
 -    av_freep(&picture->data[0]);
 -    av_frame_free(&picture);
++            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
+             fwrite(pkt.data, 1, pkt.size, f);
+             av_free_packet(&pkt);
+         }
+     }
+     /* add sequence end code to have a real mpeg file */
+     fwrite(endcode, 1, sizeof(endcode), f);
+     fclose(f);
+     avcodec_close(c);
+     av_free(c);
 -    f=fopen(filename,"w");
 -    fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
 -    for(i=0;i<ysize;i++)
 -        fwrite(buf + i * wrap,1,xsize,f);
++    av_freep(&frame->data[0]);
++    av_frame_free(&frame);
+     printf("\n");
+ }
+ /*
+  * Video decoding example
+  */
+ static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
+                      char *filename)
+ {
+     FILE *f;
+     int i;
 -    int frame, got_picture, len;
++    f = fopen(filename,"w");
++    fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
++    for (i = 0; i < ysize; i++)
++        fwrite(buf + i * wrap, 1, xsize, f);
+     fclose(f);
+ }
++static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,
++                              AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
++{
++    int len, got_frame;
++    char buf[1024];
++
++    len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
++    if (len < 0) {
++        fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
++        return len;
++    }
++    if (got_frame) {
++        printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
++        fflush(stdout);
++
++        /* the picture is allocated by the decoder, no need to free it */
++        snprintf(buf, sizeof(buf), outfilename, *frame_count);
++        pgm_save(frame->data[0], frame->linesize[0],
++                 avctx->width, avctx->height, buf);
++        (*frame_count)++;
++    }
++    if (pkt->data) {
++        pkt->size -= len;
++        pkt->data += len;
++    }
++    return 0;
++}
++
+ static void video_decode_example(const char *outfilename, const char *filename)
+ {
+     AVCodec *codec;
+     AVCodecContext *c= NULL;
 -    AVFrame *picture;
++    int frame_count;
+     FILE *f;
 -    char buf[1024];
++    AVFrame *frame;
+     uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
 -    printf("Video decoding\n");
+     AVPacket avpkt;
+     av_init_packet(&avpkt);
+     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
+     memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 -        fprintf(stderr, "codec not found\n");
++    printf("Decode video file %s to %s\n", filename, outfilename);
+     /* find the mpeg1 video decoder */
+     codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
+     if (!codec) {
 -    picture = av_frame_alloc();
++        fprintf(stderr, "Codec not found\n");
+         exit(1);
+     }
+     c = avcodec_alloc_context3(codec);
 -        fprintf(stderr, "could not open codec\n");
++    if (!c) {
++        fprintf(stderr, "Could not allocate video codec context\n");
++        exit(1);
++    }
+     if(codec->capabilities&CODEC_CAP_TRUNCATED)
+         c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
+     /* For some codecs, such as msmpeg4 and mpeg4, width and height
+        MUST be initialized there because this information is not
+        available in the bitstream. */
+     /* open it */
+     if (avcodec_open2(c, codec, NULL) < 0) {
 -    /* the codec gives us the frame size, in samples */
 -
++        fprintf(stderr, "Could not open codec\n");
+         exit(1);
+     }
 -        fprintf(stderr, "could not open %s\n", filename);
+     f = fopen(filename, "rb");
+     if (!f) {
 -    frame = 0;
 -    for(;;) {
++        fprintf(stderr, "Could not open %s\n", filename);
+         exit(1);
+     }
 -        while (avpkt.size > 0) {
 -            len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
 -            if (len < 0) {
 -                fprintf(stderr, "Error while decoding frame %d\n", frame);
++    frame = av_frame_alloc();
++    if (!frame) {
++        fprintf(stderr, "Could not allocate video frame\n");
++        exit(1);
++    }
++
++    frame_count = 0;
++    for (;;) {
+         avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
+         if (avpkt.size == 0)
+             break;
+         /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
+            and this is the only method to use them because you cannot
+            know the compressed data size before analysing it.
+            BUT some other codecs (msmpeg4, mpeg4) are inherently frame
+            based, so you must call them with all the data for one
+            frame exactly. You must also initialize 'width' and
+            'height' before initializing them. */
+         /* NOTE2: some codecs allow the raw parameters (frame size,
+            sample rate) to be changed at any frame. We handle this, so
+            you should also take care of it */
+         /* here, we use a stream based decoder (mpeg1video), so we
+            feed decoder and see if it could decode a frame */
+         avpkt.data = inbuf;
 -            }
 -            if (got_picture) {
 -                printf("saving frame %3d\n", frame);
 -                fflush(stdout);
 -
 -                /* the picture is allocated by the decoder. no need to
 -                   free it */
 -                snprintf(buf, sizeof(buf), outfilename, frame);
 -                pgm_save(picture->data[0], picture->linesize[0],
 -                         c->width, c->height, buf);
 -                frame++;
 -            }
 -            avpkt.size -= len;
 -            avpkt.data += len;
 -        }
++        while (avpkt.size > 0)
++            if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
+                 exit(1);
 -    len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
 -    if (got_picture) {
 -        printf("saving last frame %3d\n", frame);
 -        fflush(stdout);
 -
 -        /* the picture is allocated by the decoder. no need to
 -           free it */
 -        snprintf(buf, sizeof(buf), outfilename, frame);
 -        pgm_save(picture->data[0], picture->linesize[0],
 -                 c->width, c->height, buf);
 -        frame++;
 -    }
+     }
+     /* some codecs, such as MPEG, transmit the I and P frame with a
+        latency of one frame. You must do the following to have a
+        chance to get the last frame of the video */
+     avpkt.data = NULL;
+     avpkt.size = 0;
 -    av_frame_free(&picture);
++    decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);
+     fclose(f);
+     avcodec_close(c);
+     av_free(c);
 -    const char *filename;
++    av_frame_free(&frame);
+     printf("\n");
+ }
+ int main(int argc, char **argv)
+ {
 -    if (argc <= 1) {
 -        audio_encode_example("/tmp/test.mp2");
 -        audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
 -
 -        video_encode_example("/tmp/test.mpg");
 -        filename = "/tmp/test.mpg";
++    const char *output_type;
+     /* register all the codecs */
+     avcodec_register_all();
 -        filename = argv[1];
++    if (argc < 2) {
++        printf("usage: %s output_type\n"
++               "API example program to decode/encode a media stream with libavcodec.\n"
++               "This program generates a synthetic stream and encodes it to a file\n"
++               "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
++               "The encoded stream is then decoded and written to a raw data output.\n"
++               "output_type must be choosen between 'h264', 'mp2', 'mpg'.\n",
++               argv[0]);
++        return 1;
++    }
++    output_type = argv[1];
++
++    if (!strcmp(output_type, "h264")) {
++        video_encode_example("test.h264", AV_CODEC_ID_H264);
++    } else if (!strcmp(output_type, "mp2")) {
++        audio_encode_example("test.mp2");
++        audio_decode_example("test.sw", "test.mp2");
++    } else if (!strcmp(output_type, "mpg")) {
++        video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
++        video_decode_example("test%02d.pgm", "test.mpg");
+     } else {
 -    //    audio_decode_example("/tmp/test.sw", filename);
 -    video_decode_example("/tmp/test%d.pgm", filename);
 -
++        fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",
++                output_type);
++        return 1;
+     }
+     return 0;
+ }
@@@ -20,8 -20,8 +20,8 @@@
   * @file
   * simple audio converter
   *
-  * @example doc/examples/transcode_aac.c
+  * @example transcode_aac.c
 - * Convert an input audio file to AAC in an MP4 container using Libav.
 + * Convert an input audio file to AAC in an MP4 container using FFmpeg.
   * @author Andreas Unterweger (dustsigns@gmail.com)
   */
  
@@@ -470,11 -389,9 +470,12 @@@ OBJS-$(CONFIG_UNIX_PROTOCOL
  
  OBJS-$(HAVE_LIBC_MSVCRT)                 += file_open.o
  
 +# Windows resource file
 +SLIBOBJS-$(HAVE_GNU_WINDRES)             += avformatres.o
 +
  SKIPHEADERS-$(CONFIG_FFRTMPCRYPT_PROTOCOL) += rtmpdh.h
  SKIPHEADERS-$(CONFIG_NETWORK)            += network.h rtsp.h
  TESTPROGS = seek                                                        \
              srtp                                                        \
              url                                                         \
diff --cc library.mak
@@@ -57,12 -56,8 +56,12 @@@ $(SUBDIR)$(SLIBNAME_WITH_MAJOR): $(OBJS
        $$(LD) $(SHFLAGS) $(LDFLAGS) $$(LD_O) $$(filter %.o,$$^) $(FFEXTRALIBS)
        $(SLIB_EXTRA_CMD)
  
 +ifdef SUBDIR
 +$(SUBDIR)$(SLIBNAME_WITH_MAJOR): $(DEP_LIBS)
 +endif
 +
  clean::
-       $(RM) $(addprefix $(SUBDIR),*-example$(EXESUF) *-test$(EXESUF) $(CLEANFILES) $(CLEANSUFFIXES) $(LIBSUFFIXES)) \
+       $(RM) $(addprefix $(SUBDIR),*-test$(EXESUF) $(CLEANFILES) $(CLEANSUFFIXES) $(LIBSUFFIXES)) \
            $(CLEANSUFFIXES:%=$(SUBDIR)$(ARCH)/%)
  
  distclean:: clean