changeset 826:b9b0a15d0ad3 trunk

[svn] - start removing demuxers for video and images
author nenolod
date Mon, 12 Mar 2007 14:43:32 -0700
parents 3cbdc6e19d7c
children 81749781b75f
files ChangeLog src/ffmpeg/Makefile src/ffmpeg/libavcodec/allcodecs.c src/ffmpeg/libavformat/gif.c src/ffmpeg/libavformat/jpeg.c src/ffmpeg/libavformat/png.c
diffstat 6 files changed, 13 insertions(+), 2146 deletions(-) [+]
line wrap: on
line diff
--- a/ChangeLog	Mon Mar 12 14:37:31 2007 -0700
+++ b/ChangeLog	Mon Mar 12 14:43:32 2007 -0700
@@ -1,3 +1,16 @@
+2007-03-12 21:37:31 +0000  William Pitcock <nenolod@sacredspiral.co.uk>
+  revision [1750]
+  - make this compile again
+  
+  trunk/src/ffmpeg/Makefile               |   91 +++++++++++++++++++++++++++++--
+  trunk/src/ffmpeg/libavformat/Makefile   |   35 ------------
+  trunk/src/ffmpeg/libavformat/avformat.h |    6 +-
+  trunk/src/ffmpeg/libavformat/grab.c     |    1 
+  trunk/src/ffmpeg/libavformat/utils.c    |   93 ++++++++++++++++++++++++++++++++
+  trunk/src/ffmpeg/libavutil/common.h     |    2 
+  6 files changed, 187 insertions(+), 41 deletions(-)
+
+
 2007-03-12 21:19:59 +0000  William Pitcock <nenolod@sacredspiral.co.uk>
   revision [1748]
   - url_fsize support.
--- a/src/ffmpeg/Makefile	Mon Mar 12 14:37:31 2007 -0700
+++ b/src/ffmpeg/Makefile	Mon Mar 12 14:43:32 2007 -0700
@@ -93,7 +93,6 @@
 	libavformat/flvdec.c \
 	libavformat/flvenc.c \
 	libavformat/framehook.c \
-	libavformat/gif.c \
 	libavformat/gifdec.c \
 	libavformat/grab.c \
 	libavformat/gxf.c \
@@ -104,7 +103,6 @@
 	libavformat/img2.c \
 	libavformat/ipmovie.c \
 	libavformat/isom.c \
-	libavformat/jpeg.c \
 	libavformat/matroska.c \
 	libavformat/mm.c \
 	libavformat/mmf.c \
@@ -127,7 +125,6 @@
 	libavformat/oggparsetheora.c \
 	libavformat/oggparsevorbis.c \
 	libavformat/os_support.c \
-	libavformat/png.c \
 	libavformat/pnm.c \
 	libavformat/psxstr.c \
 	libavformat/raw.c \
--- a/src/ffmpeg/libavcodec/allcodecs.c	Mon Mar 12 14:37:31 2007 -0700
+++ b/src/ffmpeg/libavcodec/allcodecs.c	Mon Mar 12 14:43:32 2007 -0700
@@ -40,466 +40,6 @@
         return;
     inited = 1;
 
-    /* encoders */
-#ifdef CONFIG_AC3_ENCODER
-    register_avcodec(&ac3_encoder);
-#endif //CONFIG_AC3_ENCODER
-#ifdef CONFIG_MP2_ENCODER
-    register_avcodec(&mp2_encoder);
-#endif //CONFIG_MP2_ENCODER
-#ifdef CONFIG_MP3LAME
-#ifdef CONFIG_MP3LAME_ENCODER
-    register_avcodec(&mp3lame_encoder);
-#endif //CONFIG_MP3LAME_ENCODER
-#endif
-#ifdef CONFIG_LIBVORBIS
-#if (defined CONFIG_OGGVORBIS_ENCODER && !defined CONFIG_VORBIS_ENCODER)
-    register_avcodec(&oggvorbis_encoder);
-#endif //CONFIG_OGGVORBIS_ENCODER
-#if (defined CONFIG_OGGVORBIS_DECODER && !defined CONFIG_VORBIS_DECODER)
-    register_avcodec(&oggvorbis_decoder);
-#endif //CONFIG_OGGVORBIS_DECODER
-#endif
-#ifdef CONFIG_FAAC
-#ifdef CONFIG_FAAC_ENCODER
-    register_avcodec(&faac_encoder);
-#endif //CONFIG_FAAC_ENCODER
-#endif
-#ifdef CONFIG_FLAC_ENCODER
-    register_avcodec(&flac_encoder);
-#endif
-#ifdef CONFIG_XVID
-#ifdef CONFIG_XVID_ENCODER
-    register_avcodec(&xvid_encoder);
-#endif //CONFIG_XVID_ENCODER
-#endif
-#ifdef CONFIG_MPEG1VIDEO_ENCODER
-    register_avcodec(&mpeg1video_encoder);
-#endif //CONFIG_MPEG1VIDEO_ENCODER
-#ifdef CONFIG_H264_ENCODER
-//    register_avcodec(&h264_encoder);
-#endif //CONFIG_H264_ENCODER
-#ifdef CONFIG_MPEG2VIDEO_ENCODER
-    register_avcodec(&mpeg2video_encoder);
-#endif //CONFIG_MPEG2VIDEO_ENCODER
-#ifdef CONFIG_H261_ENCODER
-    register_avcodec(&h261_encoder);
-#endif //CONFIG_H261_ENCODER
-#ifdef CONFIG_H263_ENCODER
-    register_avcodec(&h263_encoder);
-#endif //CONFIG_H263_ENCODER
-#ifdef CONFIG_H263P_ENCODER
-    register_avcodec(&h263p_encoder);
-#endif //CONFIG_H263P_ENCODER
-#ifdef CONFIG_FLV_ENCODER
-    register_avcodec(&flv_encoder);
-#endif //CONFIG_FLV_ENCODER
-#ifdef CONFIG_RV10_ENCODER
-    register_avcodec(&rv10_encoder);
-#endif //CONFIG_RV10_ENCODER
-#ifdef CONFIG_RV20_ENCODER
-    register_avcodec(&rv20_encoder);
-#endif //CONFIG_RV20_ENCODER
-#ifdef CONFIG_MPEG4_ENCODER
-    register_avcodec(&mpeg4_encoder);
-#endif //CONFIG_MPEG4_ENCODER
-#ifdef CONFIG_MSMPEG4V1_ENCODER
-    register_avcodec(&msmpeg4v1_encoder);
-#endif //CONFIG_MSMPEG4V1_ENCODER
-#ifdef CONFIG_MSMPEG4V2_ENCODER
-    register_avcodec(&msmpeg4v2_encoder);
-#endif //CONFIG_MSMPEG4V2_ENCODER
-#ifdef CONFIG_MSMPEG4V3_ENCODER
-    register_avcodec(&msmpeg4v3_encoder);
-#endif //CONFIG_MSMPEG4V3_ENCODER
-#ifdef CONFIG_WMV1_ENCODER
-    register_avcodec(&wmv1_encoder);
-#endif //CONFIG_WMV1_ENCODER
-#ifdef CONFIG_WMV2_ENCODER
-    register_avcodec(&wmv2_encoder);
-#endif //CONFIG_WMV2_ENCODER
-#ifdef CONFIG_SVQ1_ENCODER
-    register_avcodec(&svq1_encoder);
-#endif //CONFIG_SVQ1_ENCODER
-#ifdef CONFIG_MJPEG_ENCODER
-    register_avcodec(&mjpeg_encoder);
-#endif //CONFIG_MJPEG_ENCODER
-#ifdef CONFIG_LJPEG_ENCODER
-    register_avcodec(&ljpeg_encoder);
-#endif //CONFIG_LJPEG_ENCODER
-#ifdef CONFIG_JPEGLS_ENCODER
-    register_avcodec(&jpegls_encoder);
-#endif //CONFIG_JPEGLS_ENCODER
-#ifdef CONFIG_ZLIB
-#ifdef CONFIG_PNG_ENCODER
-    register_avcodec(&png_encoder);
-#endif //CONFIG_PNG_ENCODER
-#endif
-#ifdef CONFIG_PPM_ENCODER
-    register_avcodec(&ppm_encoder);
-#endif //CONFIG_PPM_ENCODER
-#ifdef CONFIG_PGM_ENCODER
-    register_avcodec(&pgm_encoder);
-#endif //CONFIG_PGM_ENCODER
-#ifdef CONFIG_PGMYUV_ENCODER
-    register_avcodec(&pgmyuv_encoder);
-#endif //CONFIG_PGMYUV_ENCODER
-#ifdef CONFIG_PBM_ENCODER
-    register_avcodec(&pbm_encoder);
-#endif //CONFIG_PBM_ENCODER
-#ifdef CONFIG_PAM_ENCODER
-    register_avcodec(&pam_encoder);
-#endif //CONFIG_PAM_ENCODER
-#ifdef CONFIG_HUFFYUV_ENCODER
-    register_avcodec(&huffyuv_encoder);
-#endif //CONFIG_HUFFYUV_ENCODER
-#ifdef CONFIG_FFVHUFF_ENCODER
-    register_avcodec(&ffvhuff_encoder);
-#endif //CONFIG_FFVHUFF_ENCODER
-#ifdef CONFIG_ASV1_ENCODER
-    register_avcodec(&asv1_encoder);
-#endif //CONFIG_ASV1_ENCODER
-#ifdef CONFIG_ASV2_ENCODER
-    register_avcodec(&asv2_encoder);
-#endif //CONFIG_ASV2_ENCODER
-#ifdef CONFIG_FFV1_ENCODER
-    register_avcodec(&ffv1_encoder);
-#endif //CONFIG_FFV1_ENCODER
-#ifdef CONFIG_SNOW_ENCODER
-    register_avcodec(&snow_encoder);
-#endif //CONFIG_SNOW_ENCODER
-#ifdef CONFIG_ZLIB_ENCODER
-    register_avcodec(&zlib_encoder);
-#endif //CONFIG_ZLIB_ENCODER
-#ifdef CONFIG_DVVIDEO_ENCODER
-    register_avcodec(&dvvideo_encoder);
-#endif //CONFIG_DVVIDEO_ENCODER
-#ifdef CONFIG_SONIC_ENCODER
-    register_avcodec(&sonic_encoder);
-#endif //CONFIG_SONIC_ENCODER
-#ifdef CONFIG_SONIC_LS_ENCODER
-    register_avcodec(&sonic_ls_encoder);
-#endif //CONFIG_SONIC_LS_ENCODER
-#ifdef CONFIG_X264
-#ifdef CONFIG_X264_ENCODER
-    register_avcodec(&x264_encoder);
-#endif //CONFIG_X264_ENCODER
-#endif
-#ifdef CONFIG_LIBGSM
-    register_avcodec(&libgsm_encoder);
-#endif //CONFIG_LIBGSM
-#ifdef CONFIG_RAWVIDEO_ENCODER
-    register_avcodec(&rawvideo_encoder);
-#endif //CONFIG_RAWVIDEO_ENCODER
-
-    /* decoders */
-#ifdef CONFIG_GIF_DECODER
-    register_avcodec(&gif_decoder);
-#endif
-#ifdef CONFIG_H263_DECODER
-    register_avcodec(&h263_decoder);
-#endif //CONFIG_H263_DECODER
-#ifdef CONFIG_H261_DECODER
-    register_avcodec(&h261_decoder);
-#endif //CONFIG_H261_DECODER
-#ifdef CONFIG_MPEG4_DECODER
-    register_avcodec(&mpeg4_decoder);
-#endif //CONFIG_MPEG4_DECODER
-#ifdef CONFIG_MSMPEG4V1_DECODER
-    register_avcodec(&msmpeg4v1_decoder);
-#endif //CONFIG_MSMPEG4V1_DECODER
-#ifdef CONFIG_MSMPEG4V2_DECODER
-    register_avcodec(&msmpeg4v2_decoder);
-#endif //CONFIG_MSMPEG4V2_DECODER
-#ifdef CONFIG_MSMPEG4V3_DECODER
-    register_avcodec(&msmpeg4v3_decoder);
-#endif //CONFIG_MSMPEG4V3_DECODER
-#ifdef CONFIG_WMV1_DECODER
-    register_avcodec(&wmv1_decoder);
-#endif //CONFIG_WMV1_DECODER
-#ifdef CONFIG_WMV2_DECODER
-    register_avcodec(&wmv2_decoder);
-#endif //CONFIG_WMV2_DECODER
-#ifdef CONFIG_VC1_DECODER
-    register_avcodec(&vc1_decoder);
-#endif //CONFIG_VC1_DECODER
-#ifdef CONFIG_WMV3_DECODER
-    register_avcodec(&wmv3_decoder);
-#endif //CONFIG_WMV3_DECODER
-#ifdef CONFIG_H263I_DECODER
-    register_avcodec(&h263i_decoder);
-#endif //CONFIG_H263I_DECODER
-#ifdef CONFIG_FLV_DECODER
-    register_avcodec(&flv_decoder);
-#endif //CONFIG_FLV_DECODER
-#ifdef CONFIG_RV10_DECODER
-    register_avcodec(&rv10_decoder);
-#endif //CONFIG_RV10_DECODER
-#ifdef CONFIG_RV20_DECODER
-    register_avcodec(&rv20_decoder);
-#endif //CONFIG_RV20_DECODER
-#ifdef CONFIG_SVQ1_DECODER
-    register_avcodec(&svq1_decoder);
-#endif //CONFIG_SVQ1_DECODER
-#ifdef CONFIG_SVQ3_DECODER
-    register_avcodec(&svq3_decoder);
-#endif //CONFIG_SVQ3_DECODER
-#ifdef CONFIG_WMAV1_DECODER
-    register_avcodec(&wmav1_decoder);
-#endif //CONFIG_WMAV1_DECODER
-#ifdef CONFIG_WMAV2_DECODER
-    register_avcodec(&wmav2_decoder);
-#endif //CONFIG_WMAV2_DECODER
-#ifdef CONFIG_INDEO2_DECODER
-    register_avcodec(&indeo2_decoder);
-#endif //CONFIG_INDEO2_DECODER
-#ifdef CONFIG_INDEO3_DECODER
-    register_avcodec(&indeo3_decoder);
-#endif //CONFIG_INDEO3_DECODER
-#ifdef CONFIG_TSCC_DECODER
-    register_avcodec(&tscc_decoder);
-#endif //CONFIG_TSCC_DECODER
-#ifdef CONFIG_CSCD_DECODER
-    register_avcodec(&cscd_decoder);
-#endif //CONFIG_CSCD_DECODER
-#ifdef CONFIG_NUV_DECODER
-    register_avcodec(&nuv_decoder);
-#endif //CONFIG_NUV_DECODER
-#ifdef CONFIG_ULTI_DECODER
-    register_avcodec(&ulti_decoder);
-#endif //CONFIG_ULTI_DECODER
-#ifdef CONFIG_QDRAW_DECODER
-    register_avcodec(&qdraw_decoder);
-#endif //CONFIG_QDRAW_DECODER
-#ifdef CONFIG_XL_DECODER
-    register_avcodec(&xl_decoder);
-#endif //CONFIG_XL_DECODER
-#ifdef CONFIG_QPEG_DECODER
-    register_avcodec(&qpeg_decoder);
-#endif //CONFIG_QPEG_DECODER
-#ifdef CONFIG_LOCO_DECODER
-    register_avcodec(&loco_decoder);
-#endif //CONFIG_LOCO_DECODER
-#ifdef CONFIG_KMVC_DECODER
-    register_avcodec(&kmvc_decoder);
-#endif //CONFIG_KMVC_DECODER
-#ifdef CONFIG_WNV1_DECODER
-    register_avcodec(&wnv1_decoder);
-#endif //CONFIG_WNV1_DECODER
-#ifdef CONFIG_AASC_DECODER
-    register_avcodec(&aasc_decoder);
-#endif //CONFIG_AASC_DECODER
-#ifdef CONFIG_FRAPS_DECODER
-    register_avcodec(&fraps_decoder);
-#endif //CONFIG_FRAPS_DECODER
-#ifdef CONFIG_FAAD
-#ifdef CONFIG_AAC_DECODER
-    register_avcodec(&aac_decoder);
-#endif //CONFIG_AAC_DECODER
-#ifdef CONFIG_MPEG4AAC_DECODER
-    register_avcodec(&mpeg4aac_decoder);
-#endif //CONFIG_MPEG4AAC_DECODER
-#endif
-#ifdef CONFIG_MPEG1VIDEO_DECODER
-    register_avcodec(&mpeg1video_decoder);
-#endif //CONFIG_MPEG1VIDEO_DECODER
-#ifdef CONFIG_MPEG2VIDEO_DECODER
-    register_avcodec(&mpeg2video_decoder);
-#endif //CONFIG_MPEG2VIDEO_DECODER
-#ifdef CONFIG_MPEGVIDEO_DECODER
-    register_avcodec(&mpegvideo_decoder);
-#endif //CONFIG_MPEGVIDEO_DECODER
-#ifdef HAVE_XVMC
-#ifdef CONFIG_MPEG_XVMC_DECODER
-    register_avcodec(&mpeg_xvmc_decoder);
-#endif //CONFIG_MPEG_XVMC_DECODER
-#endif
-#ifdef CONFIG_DVVIDEO_DECODER
-    register_avcodec(&dvvideo_decoder);
-#endif //CONFIG_DVVIDEO_DECODER
-#ifdef CONFIG_MJPEG_DECODER
-    register_avcodec(&mjpeg_decoder);
-#endif //CONFIG_MJPEG_DECODER
-#ifdef CONFIG_MJPEGB_DECODER
-    register_avcodec(&mjpegb_decoder);
-#endif //CONFIG_MJPEGB_DECODER
-#ifdef CONFIG_SP5X_DECODER
-    register_avcodec(&sp5x_decoder);
-#endif //CONFIG_SP5X_DECODER
-#ifdef CONFIG_ZLIB
-#ifdef CONFIG_PNG_DECODER
-    register_avcodec(&png_decoder);
-#endif //CONFIG_PNG_DECODER
-#endif
-#ifdef CONFIG_MP2_DECODER
-    register_avcodec(&mp2_decoder);
-#endif //CONFIG_MP2_DECODER
-#ifdef CONFIG_MP3_DECODER
-    register_avcodec(&mp3_decoder);
-#endif //CONFIG_MP3_DECODER
-#ifdef CONFIG_MP3ADU_DECODER
-    register_avcodec(&mp3adu_decoder);
-#endif //CONFIG_MP3ADU_DECODER
-#ifdef CONFIG_MP3ON4_DECODER
-    register_avcodec(&mp3on4_decoder);
-#endif //CONFIG_MP3ON4_DECODER
-#ifdef CONFIG_MACE3_DECODER
-    register_avcodec(&mace3_decoder);
-#endif //CONFIG_MACE3_DECODER
-#ifdef CONFIG_MACE6_DECODER
-    register_avcodec(&mace6_decoder);
-#endif //CONFIG_MACE6_DECODER
-#ifdef CONFIG_HUFFYUV_DECODER
-    register_avcodec(&huffyuv_decoder);
-#endif //CONFIG_HUFFYUV_DECODER
-#ifdef CONFIG_FFVHUFF_DECODER
-    register_avcodec(&ffvhuff_decoder);
-#endif //CONFIG_FFVHUFF_DECODER
-#ifdef CONFIG_FFV1_DECODER
-    register_avcodec(&ffv1_decoder);
-#endif //CONFIG_FFV1_DECODER
-#ifdef CONFIG_SNOW_DECODER
-    register_avcodec(&snow_decoder);
-#endif //CONFIG_SNOW_DECODER
-#ifdef CONFIG_CYUV_DECODER
-    register_avcodec(&cyuv_decoder);
-#endif //CONFIG_CYUV_DECODER
-#ifdef CONFIG_H264_DECODER
-    register_avcodec(&h264_decoder);
-#endif //CONFIG_H264_DECODER
-#ifdef CONFIG_VP3_DECODER
-    register_avcodec(&vp3_decoder);
-#endif //CONFIG_VP3_DECODER
-#ifdef CONFIG_THEORA_DECODER
-    register_avcodec(&theora_decoder);
-#endif //CONFIG_THEORA_DECODER
-#ifdef CONFIG_VP5_DECODER
-    register_avcodec(&vp5_decoder);
-#endif //CONFIG_VP5_DECODER
-#ifdef CONFIG_VP6_DECODER
-    register_avcodec(&vp6_decoder);
-#endif //CONFIG_VP6_DECODER
-#ifdef CONFIG_VP6F_DECODER
-    register_avcodec(&vp6f_decoder);
-#endif //CONFIG_VP6F_DECODER
-#ifdef CONFIG_ASV1_DECODER
-    register_avcodec(&asv1_decoder);
-#endif //CONFIG_ASV1_DECODER
-#ifdef CONFIG_ASV2_DECODER
-    register_avcodec(&asv2_decoder);
-#endif //CONFIG_ASV2_DECODER
-#ifdef CONFIG_VCR1_DECODER
-    register_avcodec(&vcr1_decoder);
-#endif //CONFIG_VCR1_DECODER
-#ifdef CONFIG_CLJR_DECODER
-    register_avcodec(&cljr_decoder);
-#endif //CONFIG_CLJR_DECODER
-#ifdef CONFIG_FOURXM_DECODER
-    register_avcodec(&fourxm_decoder);
-#endif //CONFIG_FOURXM_DECODER
-#ifdef CONFIG_MDEC_DECODER
-    register_avcodec(&mdec_decoder);
-#endif //CONFIG_MDEC_DECODER
-#ifdef CONFIG_ROQ_DECODER
-    register_avcodec(&roq_decoder);
-#endif //CONFIG_ROQ_DECODER
-#ifdef CONFIG_INTERPLAY_VIDEO_DECODER
-    register_avcodec(&interplay_video_decoder);
-#endif //CONFIG_INTERPLAY_VIDEO_DECODER
-#ifdef CONFIG_XAN_WC3_DECODER
-    register_avcodec(&xan_wc3_decoder);
-#endif //CONFIG_XAN_WC3_DECODER
-#ifdef CONFIG_RPZA_DECODER
-    register_avcodec(&rpza_decoder);
-#endif //CONFIG_RPZA_DECODER
-#ifdef CONFIG_CINEPAK_DECODER
-    register_avcodec(&cinepak_decoder);
-#endif //CONFIG_CINEPAK_DECODER
-#ifdef CONFIG_MSRLE_DECODER
-    register_avcodec(&msrle_decoder);
-#endif //CONFIG_MSRLE_DECODER
-#ifdef CONFIG_MSVIDEO1_DECODER
-    register_avcodec(&msvideo1_decoder);
-#endif //CONFIG_MSVIDEO1_DECODER
-#ifdef CONFIG_VQA_DECODER
-    register_avcodec(&vqa_decoder);
-#endif //CONFIG_VQA_DECODER
-#ifdef CONFIG_IDCIN_DECODER
-    register_avcodec(&idcin_decoder);
-#endif //CONFIG_IDCIN_DECODER
-#ifdef CONFIG_EIGHTBPS_DECODER
-    register_avcodec(&eightbps_decoder);
-#endif //CONFIG_EIGHTBPS_DECODER
-#ifdef CONFIG_SMC_DECODER
-    register_avcodec(&smc_decoder);
-#endif //CONFIG_SMC_DECODER
-#ifdef CONFIG_FLIC_DECODER
-    register_avcodec(&flic_decoder);
-#endif //CONFIG_FLIC_DECODER
-#ifdef CONFIG_TRUEMOTION1_DECODER
-    register_avcodec(&truemotion1_decoder);
-#endif //CONFIG_TRUEMOTION1_DECODER
-#ifdef CONFIG_TRUEMOTION2_DECODER
-    register_avcodec(&truemotion2_decoder);
-#endif //CONFIG_TRUEMOTION2_DECODER
-#ifdef CONFIG_VMDVIDEO_DECODER
-    register_avcodec(&vmdvideo_decoder);
-#endif //CONFIG_VMDVIDEO_DECODER
-#ifdef CONFIG_VMDAUDIO_DECODER
-    register_avcodec(&vmdaudio_decoder);
-#endif //CONFIG_VMDAUDIO_DECODER
-#ifdef CONFIG_MSZH_DECODER
-    register_avcodec(&mszh_decoder);
-#endif //CONFIG_MSZH_DECODER
-#ifdef CONFIG_ZLIB_DECODER
-    register_avcodec(&zlib_decoder);
-#endif //CONFIG_ZLIB_DECODER
-#ifdef CONFIG_ZMBV_DECODER
-    register_avcodec(&zmbv_decoder);
-#endif //CONFIG_ZMBV_DECODER
-#ifdef CONFIG_SMACKER_DECODER
-    register_avcodec(&smacker_decoder);
-#endif //CONFIG_SMACKER_DECODER
-#ifdef CONFIG_SMACKAUD_DECODER
-    register_avcodec(&smackaud_decoder);
-#endif //CONFIG_SMACKAUD_DECODER
-#ifdef CONFIG_SONIC_DECODER
-    register_avcodec(&sonic_decoder);
-#endif //CONFIG_SONIC_DECODER
-#ifdef CONFIG_AC3
-#ifdef CONFIG_AC3_DECODER
-    register_avcodec(&ac3_decoder);
-#endif //CONFIG_AC3_DECODER
-#endif
-#ifdef CONFIG_DTS
-#ifdef CONFIG_DTS_DECODER
-    register_avcodec(&dts_decoder);
-#endif //CONFIG_DTS_DECODER
-#endif
-#ifdef CONFIG_RA_144_DECODER
-    register_avcodec(&ra_144_decoder);
-#endif //CONFIG_RA_144_DECODER
-#ifdef CONFIG_RA_288_DECODER
-    register_avcodec(&ra_288_decoder);
-#endif //CONFIG_RA_288_DECODER
-#ifdef CONFIG_ROQ_DPCM_DECODER
-    register_avcodec(&roq_dpcm_decoder);
-#endif //CONFIG_ROQ_DPCM_DECODER
-#ifdef CONFIG_INTERPLAY_DPCM_DECODER
-    register_avcodec(&interplay_dpcm_decoder);
-#endif //CONFIG_INTERPLAY_DPCM_DECODER
-#ifdef CONFIG_XAN_DPCM_DECODER
-    register_avcodec(&xan_dpcm_decoder);
-#endif //CONFIG_XAN_DPCM_DECODER
-#ifdef CONFIG_SOL_DPCM_DECODER
-    register_avcodec(&sol_dpcm_decoder);
-#endif //CONFIG_SOL_DPCM_DECODER
-#ifdef CONFIG_QTRLE_DECODER
-    register_avcodec(&qtrle_decoder);
-#endif //CONFIG_QTRLE_DECODER
-#ifdef CONFIG_FLAC_DECODER
-    register_avcodec(&flac_decoder);
-#endif //CONFIG_FLAC_DECODER
 #ifdef CONFIG_SHORTEN_DECODER
     register_avcodec(&shorten_decoder);
 #endif //CONFIG_SHORTEN_DECODER
@@ -509,18 +49,6 @@
 #ifdef CONFIG_WS_SND1_DECODER
     register_avcodec(&ws_snd1_decoder);
 #endif //CONFIG_WS_SND1_DECODER
-#ifdef CONFIG_VORBIS_DECODER
-    register_avcodec(&vorbis_decoder);
-#endif
-#ifdef CONFIG_VORBIS_ENCODER
-    register_avcodec(&vorbis_encoder);
-#endif
-#ifdef CONFIG_LIBGSM
-    register_avcodec(&libgsm_decoder);
-#endif //CONFIG_LIBGSM
-#ifdef CONFIG_QDM2_DECODER
-    register_avcodec(&qdm2_decoder);
-#endif //CONFIG_QDM2_DECODER
 #ifdef CONFIG_COOK_DECODER
     register_avcodec(&cook_decoder);
 #endif //CONFIG_COOK_DECODER
@@ -530,65 +58,9 @@
 #ifdef CONFIG_TTA_DECODER
     register_avcodec(&tta_decoder);
 #endif //CONFIG_TTA_DECODER
-#ifdef CONFIG_AVS_DECODER
-    register_avcodec(&avs_decoder);
-#endif //CONFIG_AVS_DECODER
-#ifdef CONFIG_CAVS_DECODER
-    register_avcodec(&cavs_decoder);
-#endif //CONFIG_CAVS_DECODER
-#ifdef CONFIG_RAWVIDEO_DECODER
-    register_avcodec(&rawvideo_decoder);
-#endif //CONFIG_RAWVIDEO_DECODER
-#ifdef CONFIG_FLASHSV_DECODER
-    register_avcodec(&flashsv_decoder);
-#endif //CONFIG_FLASHSV_DECODER
-#ifdef CONFIG_VMNC_DECODER
-    register_avcodec(&vmnc_decoder);
-#endif //CONFIG_VMNC_DECODER
 #ifdef CONFIG_WAVPACK_DECODER
     register_avcodec(&wavpack_decoder);
 #endif //CONFIG_WAVPACK_DECODER
-#ifdef CONFIG_TARGA_DECODER
-    register_avcodec(&targa_decoder);
-#endif //CONFIG_TARGA_DECODER
-#ifdef CONFIG_DSICINVIDEO_DECODER
-    register_avcodec(&dsicinvideo_decoder);
-#endif //CONFIG_DSICINVIDEO_DECODER
-#ifdef CONFIG_DSICINAUDIO_DECODER
-    register_avcodec(&dsicinaudio_decoder);
-#endif //CONFIG_DSICINAUDIO_DECODER
-#ifdef CONFIG_TIERTEXSEQVIDEO_DECODER
-    register_avcodec(&tiertexseqvideo_decoder);
-#endif //CONFIG_TIERTEXSEQVIDEO_DECODER
-#ifdef CONFIG_TIFF_DECODER
-    register_avcodec(&tiff_decoder);
-#endif //CONFIG_TIFF_DECODER
-
-#if defined(CONFIG_AMR_NB) || defined(CONFIG_AMR_NB_FIXED)
-#ifdef CONFIG_AMR_NB_DECODER
-    register_avcodec(&amr_nb_decoder);
-#endif //CONFIG_AMR_NB_DECODER
-#ifdef CONFIG_AMR_NB_ENCODER
-    register_avcodec(&amr_nb_encoder);
-#endif //CONFIG_AMR_NB_ENCODER
-#endif /* CONFIG_AMR_NB || CONFIG_AMR_NB_FIXED */
-
-#ifdef CONFIG_AMR_WB
-#ifdef CONFIG_AMR_WB_DECODER
-    register_avcodec(&amr_wb_decoder);
-#endif //CONFIG_AMR_WB_DECODER
-#ifdef CONFIG_AMR_WB_ENCODER
-    register_avcodec(&amr_wb_encoder);
-#endif //CONFIG_AMR_WB_ENCODER
-#endif /* CONFIG_AMR_WB */
-
-#ifdef CONFIG_BMP_DECODER
-    register_avcodec(&bmp_decoder);
-#endif
-
-#if CONFIG_MMVIDEO_DECODER
-    register_avcodec(&mmvideo_decoder);
-#endif //CONFIG_MMVIDEO_DECODER
 
     /* pcm codecs */
 #ifdef CONFIG_PCM_S32LE_DECODER
@@ -804,61 +276,7 @@
     register_avcodec(&adpcm_sbpro_2_encoder);
 #endif
 
-    /* subtitles */
-#ifdef CONFIG_DVDSUB_DECODER
-    register_avcodec(&dvdsub_decoder);
-#endif
-#ifdef CONFIG_DVDSUB_ENCODER
-    register_avcodec(&dvdsub_encoder);
-#endif
-
-#ifdef CONFIG_DVBSUB_DECODER
-    register_avcodec(&dvbsub_decoder);
-#endif
-#ifdef CONFIG_DVBSUB_ENCODER
-    register_avcodec(&dvbsub_encoder);
-#endif
-
     /* parsers */
-#ifdef CONFIG_MPEGVIDEO_PARSER
-    av_register_codec_parser(&mpegvideo_parser);
-#endif
-#ifdef CONFIG_MPEG4VIDEO_PARSER
-    av_register_codec_parser(&mpeg4video_parser);
-#endif
-#ifdef CONFIG_CAVSVIDEO_PARSER
-    av_register_codec_parser(&cavsvideo_parser);
-#endif
-#ifdef CONFIG_H261_PARSER
-    av_register_codec_parser(&h261_parser);
-#endif
-#ifdef CONFIG_H263_PARSER
-    av_register_codec_parser(&h263_parser);
-#endif
-#ifdef CONFIG_H264_PARSER
-    av_register_codec_parser(&h264_parser);
-#endif
-#ifdef CONFIG_MJPEG_PARSER
-    av_register_codec_parser(&mjpeg_parser);
-#endif
-#ifdef CONFIG_PNM_PARSER
-    av_register_codec_parser(&pnm_parser);
-#endif
-#ifdef CONFIG_MPEGAUDIO_PARSER
-    av_register_codec_parser(&mpegaudio_parser);
-#endif
-#ifdef CONFIG_AC3_PARSER
-    av_register_codec_parser(&ac3_parser);
-#endif
-#ifdef CONFIG_DVDSUB_PARSER
-    av_register_codec_parser(&dvdsub_parser);
-#endif
-#ifdef CONFIG_DVBSUB_PARSER
-    av_register_codec_parser(&dvbsub_parser);
-#endif
-#ifdef CONFIG_AAC_PARSER
-    av_register_codec_parser(&aac_parser);
-#endif
 
     av_register_bitstream_filter(&dump_extradata_bsf);
     av_register_bitstream_filter(&remove_extradata_bsf);
--- a/src/ffmpeg/libavformat/gif.c	Mon Mar 12 14:37:31 2007 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,432 +0,0 @@
-/*
- * Animated GIF encoder
- * Copyright (c) 2000 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
- */
-
-/*
- * First version by Francois Revol revol@free.fr
- *
- * Features and limitations:
- * - currently no compression is performed,
- *   in fact the size of the data is 9/8 the size of the image in 8bpp
- * - uses only a global standard palette
- * - tested with IE 5.0, Opera for BeOS, NetPositive (BeOS), and Mozilla (BeOS).
- *
- * Reference documents:
- * http://www.goice.co.jp/member/mo/formats/gif.html
- * http://astronomy.swin.edu.au/pbourke/dataformats/gif/
- * http://www.dcs.ed.ac.uk/home/mxr/gfx/2d/GIF89a.txt
- *
- * this url claims to have an LZW algorithm not covered by Unisys patent:
- * http://www.msg.net/utility/whirlgif/gifencod.html
- * could help reduce the size of the files _a lot_...
- * some sites mentions an RLE type compression also.
- */
-
-#include "avformat.h"
-#include "bitstream.h"
-
-/* bitstream minipacket size */
-#define GIF_CHUNKS 100
-
-/* slows down the decoding (and some browsers don't like it) */
-/* update on the 'some browsers don't like it issue from above: this was probably due to missing 'Data Sub-block Terminator' (byte 19) in the app_header */
-#define GIF_ADD_APP_HEADER // required to enable looping of animated gif
-
-typedef struct {
-    unsigned char r;
-    unsigned char g;
-    unsigned char b;
-} rgb_triplet;
-
-/* we use the standard 216 color palette */
-
-/* this script was used to create the palette:
- * for r in 00 33 66 99 cc ff; do for g in 00 33 66 99 cc ff; do echo -n "    "; for b in 00 33 66 99 cc ff; do
- *   echo -n "{ 0x$r, 0x$g, 0x$b }, "; done; echo ""; done; done
- */
-
-static const rgb_triplet gif_clut[216] = {
-    { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x33 }, { 0x00, 0x00, 0x66 }, { 0x00, 0x00, 0x99 }, { 0x00, 0x00, 0xcc }, { 0x00, 0x00, 0xff },
-    { 0x00, 0x33, 0x00 }, { 0x00, 0x33, 0x33 }, { 0x00, 0x33, 0x66 }, { 0x00, 0x33, 0x99 }, { 0x00, 0x33, 0xcc }, { 0x00, 0x33, 0xff },
-    { 0x00, 0x66, 0x00 }, { 0x00, 0x66, 0x33 }, { 0x00, 0x66, 0x66 }, { 0x00, 0x66, 0x99 }, { 0x00, 0x66, 0xcc }, { 0x00, 0x66, 0xff },
-    { 0x00, 0x99, 0x00 }, { 0x00, 0x99, 0x33 }, { 0x00, 0x99, 0x66 }, { 0x00, 0x99, 0x99 }, { 0x00, 0x99, 0xcc }, { 0x00, 0x99, 0xff },
-    { 0x00, 0xcc, 0x00 }, { 0x00, 0xcc, 0x33 }, { 0x00, 0xcc, 0x66 }, { 0x00, 0xcc, 0x99 }, { 0x00, 0xcc, 0xcc }, { 0x00, 0xcc, 0xff },
-    { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0x33 }, { 0x00, 0xff, 0x66 }, { 0x00, 0xff, 0x99 }, { 0x00, 0xff, 0xcc }, { 0x00, 0xff, 0xff },
-    { 0x33, 0x00, 0x00 }, { 0x33, 0x00, 0x33 }, { 0x33, 0x00, 0x66 }, { 0x33, 0x00, 0x99 }, { 0x33, 0x00, 0xcc }, { 0x33, 0x00, 0xff },
-    { 0x33, 0x33, 0x00 }, { 0x33, 0x33, 0x33 }, { 0x33, 0x33, 0x66 }, { 0x33, 0x33, 0x99 }, { 0x33, 0x33, 0xcc }, { 0x33, 0x33, 0xff },
-    { 0x33, 0x66, 0x00 }, { 0x33, 0x66, 0x33 }, { 0x33, 0x66, 0x66 }, { 0x33, 0x66, 0x99 }, { 0x33, 0x66, 0xcc }, { 0x33, 0x66, 0xff },
-    { 0x33, 0x99, 0x00 }, { 0x33, 0x99, 0x33 }, { 0x33, 0x99, 0x66 }, { 0x33, 0x99, 0x99 }, { 0x33, 0x99, 0xcc }, { 0x33, 0x99, 0xff },
-    { 0x33, 0xcc, 0x00 }, { 0x33, 0xcc, 0x33 }, { 0x33, 0xcc, 0x66 }, { 0x33, 0xcc, 0x99 }, { 0x33, 0xcc, 0xcc }, { 0x33, 0xcc, 0xff },
-    { 0x33, 0xff, 0x00 }, { 0x33, 0xff, 0x33 }, { 0x33, 0xff, 0x66 }, { 0x33, 0xff, 0x99 }, { 0x33, 0xff, 0xcc }, { 0x33, 0xff, 0xff },
-    { 0x66, 0x00, 0x00 }, { 0x66, 0x00, 0x33 }, { 0x66, 0x00, 0x66 }, { 0x66, 0x00, 0x99 }, { 0x66, 0x00, 0xcc }, { 0x66, 0x00, 0xff },
-    { 0x66, 0x33, 0x00 }, { 0x66, 0x33, 0x33 }, { 0x66, 0x33, 0x66 }, { 0x66, 0x33, 0x99 }, { 0x66, 0x33, 0xcc }, { 0x66, 0x33, 0xff },
-    { 0x66, 0x66, 0x00 }, { 0x66, 0x66, 0x33 }, { 0x66, 0x66, 0x66 }, { 0x66, 0x66, 0x99 }, { 0x66, 0x66, 0xcc }, { 0x66, 0x66, 0xff },
-    { 0x66, 0x99, 0x00 }, { 0x66, 0x99, 0x33 }, { 0x66, 0x99, 0x66 }, { 0x66, 0x99, 0x99 }, { 0x66, 0x99, 0xcc }, { 0x66, 0x99, 0xff },
-    { 0x66, 0xcc, 0x00 }, { 0x66, 0xcc, 0x33 }, { 0x66, 0xcc, 0x66 }, { 0x66, 0xcc, 0x99 }, { 0x66, 0xcc, 0xcc }, { 0x66, 0xcc, 0xff },
-    { 0x66, 0xff, 0x00 }, { 0x66, 0xff, 0x33 }, { 0x66, 0xff, 0x66 }, { 0x66, 0xff, 0x99 }, { 0x66, 0xff, 0xcc }, { 0x66, 0xff, 0xff },
-    { 0x99, 0x00, 0x00 }, { 0x99, 0x00, 0x33 }, { 0x99, 0x00, 0x66 }, { 0x99, 0x00, 0x99 }, { 0x99, 0x00, 0xcc }, { 0x99, 0x00, 0xff },
-    { 0x99, 0x33, 0x00 }, { 0x99, 0x33, 0x33 }, { 0x99, 0x33, 0x66 }, { 0x99, 0x33, 0x99 }, { 0x99, 0x33, 0xcc }, { 0x99, 0x33, 0xff },
-    { 0x99, 0x66, 0x00 }, { 0x99, 0x66, 0x33 }, { 0x99, 0x66, 0x66 }, { 0x99, 0x66, 0x99 }, { 0x99, 0x66, 0xcc }, { 0x99, 0x66, 0xff },
-    { 0x99, 0x99, 0x00 }, { 0x99, 0x99, 0x33 }, { 0x99, 0x99, 0x66 }, { 0x99, 0x99, 0x99 }, { 0x99, 0x99, 0xcc }, { 0x99, 0x99, 0xff },
-    { 0x99, 0xcc, 0x00 }, { 0x99, 0xcc, 0x33 }, { 0x99, 0xcc, 0x66 }, { 0x99, 0xcc, 0x99 }, { 0x99, 0xcc, 0xcc }, { 0x99, 0xcc, 0xff },
-    { 0x99, 0xff, 0x00 }, { 0x99, 0xff, 0x33 }, { 0x99, 0xff, 0x66 }, { 0x99, 0xff, 0x99 }, { 0x99, 0xff, 0xcc }, { 0x99, 0xff, 0xff },
-    { 0xcc, 0x00, 0x00 }, { 0xcc, 0x00, 0x33 }, { 0xcc, 0x00, 0x66 }, { 0xcc, 0x00, 0x99 }, { 0xcc, 0x00, 0xcc }, { 0xcc, 0x00, 0xff },
-    { 0xcc, 0x33, 0x00 }, { 0xcc, 0x33, 0x33 }, { 0xcc, 0x33, 0x66 }, { 0xcc, 0x33, 0x99 }, { 0xcc, 0x33, 0xcc }, { 0xcc, 0x33, 0xff },
-    { 0xcc, 0x66, 0x00 }, { 0xcc, 0x66, 0x33 }, { 0xcc, 0x66, 0x66 }, { 0xcc, 0x66, 0x99 }, { 0xcc, 0x66, 0xcc }, { 0xcc, 0x66, 0xff },
-    { 0xcc, 0x99, 0x00 }, { 0xcc, 0x99, 0x33 }, { 0xcc, 0x99, 0x66 }, { 0xcc, 0x99, 0x99 }, { 0xcc, 0x99, 0xcc }, { 0xcc, 0x99, 0xff },
-    { 0xcc, 0xcc, 0x00 }, { 0xcc, 0xcc, 0x33 }, { 0xcc, 0xcc, 0x66 }, { 0xcc, 0xcc, 0x99 }, { 0xcc, 0xcc, 0xcc }, { 0xcc, 0xcc, 0xff },
-    { 0xcc, 0xff, 0x00 }, { 0xcc, 0xff, 0x33 }, { 0xcc, 0xff, 0x66 }, { 0xcc, 0xff, 0x99 }, { 0xcc, 0xff, 0xcc }, { 0xcc, 0xff, 0xff },
-    { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0x33 }, { 0xff, 0x00, 0x66 }, { 0xff, 0x00, 0x99 }, { 0xff, 0x00, 0xcc }, { 0xff, 0x00, 0xff },
-    { 0xff, 0x33, 0x00 }, { 0xff, 0x33, 0x33 }, { 0xff, 0x33, 0x66 }, { 0xff, 0x33, 0x99 }, { 0xff, 0x33, 0xcc }, { 0xff, 0x33, 0xff },
-    { 0xff, 0x66, 0x00 }, { 0xff, 0x66, 0x33 }, { 0xff, 0x66, 0x66 }, { 0xff, 0x66, 0x99 }, { 0xff, 0x66, 0xcc }, { 0xff, 0x66, 0xff },
-    { 0xff, 0x99, 0x00 }, { 0xff, 0x99, 0x33 }, { 0xff, 0x99, 0x66 }, { 0xff, 0x99, 0x99 }, { 0xff, 0x99, 0xcc }, { 0xff, 0x99, 0xff },
-    { 0xff, 0xcc, 0x00 }, { 0xff, 0xcc, 0x33 }, { 0xff, 0xcc, 0x66 }, { 0xff, 0xcc, 0x99 }, { 0xff, 0xcc, 0xcc }, { 0xff, 0xcc, 0xff },
-    { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0x33 }, { 0xff, 0xff, 0x66 }, { 0xff, 0xff, 0x99 }, { 0xff, 0xff, 0xcc }, { 0xff, 0xff, 0xff },
-};
-
-/* The GIF format uses reversed order for bitstreams... */
-/* at least they don't use PDP_ENDIAN :) */
-/* so we 'extend' PutBitContext. hmmm, OOP :) */
-/* seems this thing changed slightly since I wrote it... */
-
-#ifdef ALT_BITSTREAM_WRITER
-# error no ALT_BITSTREAM_WRITER support for now
-#endif
-
-static void gif_put_bits_rev(PutBitContext *s, int n, unsigned int value)
-{
-    unsigned int bit_buf;
-    int bit_cnt;
-
-    //    printf("put_bits=%d %x\n", n, value);
-    assert(n == 32 || value < (1U << n));
-
-    bit_buf = s->bit_buf;
-    bit_cnt = 32 - s->bit_left; /* XXX:lazyness... was = s->bit_cnt; */
-
-    //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
-    /* XXX: optimize */
-    if (n < (32-bit_cnt)) {
-        bit_buf |= value << (bit_cnt);
-        bit_cnt+=n;
-    } else {
-        bit_buf |= value << (bit_cnt);
-
-        *s->buf_ptr = bit_buf & 0xff;
-        s->buf_ptr[1] = (bit_buf >> 8) & 0xff;
-        s->buf_ptr[2] = (bit_buf >> 16) & 0xff;
-        s->buf_ptr[3] = (bit_buf >> 24) & 0xff;
-
-        //printf("bitbuf = %08x\n", bit_buf);
-        s->buf_ptr+=4;
-        if (s->buf_ptr >= s->buf_end)
-            puts("bit buffer overflow !!"); // should never happen ! who got rid of the callback ???
-//            flush_buffer_rev(s);
-        bit_cnt=bit_cnt + n - 32;
-        if (bit_cnt == 0) {
-            bit_buf = 0;
-        } else {
-            bit_buf = value >> (n - bit_cnt);
-        }
-    }
-
-    s->bit_buf = bit_buf;
-    s->bit_left = 32 - bit_cnt;
-}
-
-/* pad the end of the output stream with zeros */
-static void gif_flush_put_bits_rev(PutBitContext *s)
-{
-    while (s->bit_left < 32) {
-        /* XXX: should test end of buffer */
-        *s->buf_ptr++=s->bit_buf & 0xff;
-        s->bit_buf>>=8;
-        s->bit_left+=8;
-    }
-//    flush_buffer_rev(s);
-    s->bit_left=32;
-    s->bit_buf=0;
-}
-
-/* !RevPutBitContext */
-
-/* GIF header */
-static int gif_image_write_header(ByteIOContext *pb,
-                                  int width, int height, int loop_count,
-                                  uint32_t *palette)
-{
-    int i;
-    unsigned int v;
-
-    put_tag(pb, "GIF");
-    put_tag(pb, "89a");
-    put_le16(pb, width);
-    put_le16(pb, height);
-
-    put_byte(pb, 0xf7); /* flags: global clut, 256 entries */
-    put_byte(pb, 0x1f); /* background color index */
-    put_byte(pb, 0); /* aspect ratio */
-
-    /* the global palette */
-    if (!palette) {
-        put_buffer(pb, (const unsigned char *)gif_clut, 216*3);
-        for(i=0;i<((256-216)*3);i++)
-            put_byte(pb, 0);
-    } else {
-        for(i=0;i<256;i++) {
-            v = palette[i];
-            put_byte(pb, (v >> 16) & 0xff);
-            put_byte(pb, (v >> 8) & 0xff);
-            put_byte(pb, (v) & 0xff);
-        }
-    }
-
-        /*        update: this is the 'NETSCAPE EXTENSION' that allows for looped animated gif
-                see http://members.aol.com/royalef/gifabout.htm#net-extension
-
-                byte   1       : 33 (hex 0x21) GIF Extension code
-                byte   2       : 255 (hex 0xFF) Application Extension Label
-                byte   3       : 11 (hex (0x0B) Length of Application Block
-                                         (eleven bytes of data to follow)
-                bytes  4 to 11 : "NETSCAPE"
-                bytes 12 to 14 : "2.0"
-                byte  15       : 3 (hex 0x03) Length of Data Sub-Block
-                                         (three bytes of data to follow)
-                byte  16       : 1 (hex 0x01)
-                bytes 17 to 18 : 0 to 65535, an unsigned integer in
-                                         lo-hi byte format. This indicate the
-                                         number of iterations the loop should
-                                         be executed.
-                bytes 19       : 0 (hex 0x00) a Data Sub-block Terminator
-        */
-
-    /* application extension header */
-#ifdef GIF_ADD_APP_HEADER
-    if (loop_count >= 0 && loop_count <= 65535) {
-    put_byte(pb, 0x21);
-    put_byte(pb, 0xff);
-    put_byte(pb, 0x0b);
-        put_tag(pb, "NETSCAPE2.0");  // bytes 4 to 14
-        put_byte(pb, 0x03); // byte 15
-        put_byte(pb, 0x01); // byte 16
-        put_le16(pb, (uint16_t)loop_count);
-        put_byte(pb, 0x00); // byte 19
-    }
-#endif
-    return 0;
-}
-
-/* this is maybe slow, but allows for extensions */
-static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
-{
-    return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
-}
-
-
-static int gif_image_write_image(ByteIOContext *pb,
-                                 int x1, int y1, int width, int height,
-                                 const uint8_t *buf, int linesize, int pix_fmt)
-{
-    PutBitContext p;
-    uint8_t buffer[200]; /* 100 * 9 / 8 = 113 */
-    int i, left, w, v;
-    const uint8_t *ptr;
-    /* image block */
-
-    put_byte(pb, 0x2c);
-    put_le16(pb, x1);
-    put_le16(pb, y1);
-    put_le16(pb, width);
-    put_le16(pb, height);
-    put_byte(pb, 0x00); /* flags */
-    /* no local clut */
-
-    put_byte(pb, 0x08);
-
-    left= width * height;
-
-    init_put_bits(&p, buffer, 130);
-
-/*
- * the thing here is the bitstream is written as little packets, with a size byte before
- * but it's still the same bitstream between packets (no flush !)
- */
-    ptr = buf;
-    w = width;
-    while(left>0) {
-
-        gif_put_bits_rev(&p, 9, 0x0100); /* clear code */
-
-        for(i=(left<GIF_CHUNKS)?left:GIF_CHUNKS;i;i--) {
-            if (pix_fmt == PIX_FMT_RGB24) {
-                v = gif_clut_index(ptr[0], ptr[1], ptr[2]);
-                ptr+=3;
-            } else {
-                v = *ptr++;
-            }
-            gif_put_bits_rev(&p, 9, v);
-            if (--w == 0) {
-                w = width;
-                buf += linesize;
-                ptr = buf;
-            }
-        }
-
-        if(left<=GIF_CHUNKS) {
-            gif_put_bits_rev(&p, 9, 0x101); /* end of stream */
-            gif_flush_put_bits_rev(&p);
-        }
-        if(pbBufPtr(&p) - p.buf > 0) {
-            put_byte(pb, pbBufPtr(&p) - p.buf); /* byte count of the packet */
-            put_buffer(pb, p.buf, pbBufPtr(&p) - p.buf); /* the actual buffer */
-            p.buf_ptr = p.buf; /* dequeue the bytes off the bitstream */
-        }
-        left-=GIF_CHUNKS;
-    }
-    put_byte(pb, 0x00); /* end of image block */
-
-    return 0;
-}
-
-typedef struct {
-    int64_t time, file_time;
-    uint8_t buffer[100]; /* data chunks */
-} GIFContext;
-
-static int gif_write_header(AVFormatContext *s)
-{
-    GIFContext *gif = s->priv_data;
-    ByteIOContext *pb = &s->pb;
-    AVCodecContext *enc, *video_enc;
-    int i, width, height, loop_count /*, rate*/;
-
-/* XXX: do we reject audio streams or just ignore them ?
-    if(s->nb_streams > 1)
-        return -1;
-*/
-    gif->time = 0;
-    gif->file_time = 0;
-
-    video_enc = NULL;
-    for(i=0;i<s->nb_streams;i++) {
-        enc = s->streams[i]->codec;
-        if (enc->codec_type != CODEC_TYPE_AUDIO)
-            video_enc = enc;
-    }
-
-    if (!video_enc) {
-        av_free(gif);
-        return -1;
-    } else {
-        width = video_enc->width;
-        height = video_enc->height;
-        loop_count = s->loop_output;
-//        rate = video_enc->time_base.den;
-    }
-
-    if (video_enc->pix_fmt != PIX_FMT_RGB24) {
-        av_log(s, AV_LOG_ERROR, "ERROR: gif only handles the rgb24 pixel format. Use -pix_fmt rgb24.\n");
-        return AVERROR_IO;
-    }
-
-    gif_image_write_header(pb, width, height, loop_count, NULL);
-
-    put_flush_packet(&s->pb);
-    return 0;
-}
-
-static int gif_write_video(AVFormatContext *s,
-                           AVCodecContext *enc, const uint8_t *buf, int size)
-{
-    ByteIOContext *pb = &s->pb;
-    GIFContext *gif = s->priv_data;
-    int jiffies;
-    int64_t delay;
-
-    /* graphic control extension block */
-    put_byte(pb, 0x21);
-    put_byte(pb, 0xf9);
-    put_byte(pb, 0x04); /* block size */
-    put_byte(pb, 0x04); /* flags */
-
-    /* 1 jiffy is 1/70 s */
-    /* the delay_time field indicates the number of jiffies - 1 */
-    delay = gif->file_time - gif->time;
-
-    /* XXX: should use delay, in order to be more accurate */
-    /* instead of using the same rounded value each time */
-    /* XXX: don't even remember if I really use it for now */
-    jiffies = (70*enc->time_base.num/enc->time_base.den) - 1;
-
-    put_le16(pb, jiffies);
-
-    put_byte(pb, 0x1f); /* transparent color index */
-    put_byte(pb, 0x00);
-
-    gif_image_write_image(pb, 0, 0, enc->width, enc->height,
-                          buf, enc->width * 3, PIX_FMT_RGB24);
-
-    put_flush_packet(&s->pb);
-    return 0;
-}
-
-static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)
-{
-    AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
-    if (codec->codec_type == CODEC_TYPE_AUDIO)
-        return 0; /* just ignore audio */
-    else
-        return gif_write_video(s, codec, pkt->data, pkt->size);
-}
-
-static int gif_write_trailer(AVFormatContext *s)
-{
-    ByteIOContext *pb = &s->pb;
-
-    put_byte(pb, 0x3b);
-    put_flush_packet(&s->pb);
-    return 0;
-}
-
-/* better than nothing gif image writer */
-int gif_write(ByteIOContext *pb, AVImageInfo *info)
-{
-    gif_image_write_header(pb, info->width, info->height, AVFMT_NOOUTPUTLOOP,
-                           (uint32_t *)info->pict.data[1]);
-    gif_image_write_image(pb, 0, 0, info->width, info->height,
-                          info->pict.data[0], info->pict.linesize[0],
-                          PIX_FMT_PAL8);
-    put_byte(pb, 0x3b);
-    put_flush_packet(pb);
-    return 0;
-}
-
-AVOutputFormat gif_muxer = {
-    "gif",
-    "GIF Animation",
-    "image/gif",
-    "gif",
-    sizeof(GIFContext),
-    CODEC_ID_NONE,
-    CODEC_ID_RAWVIDEO,
-    gif_write_header,
-    gif_write_packet,
-    gif_write_trailer,
-};
--- a/src/ffmpeg/libavformat/jpeg.c	Mon Mar 12 14:37:31 2007 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,240 +0,0 @@
-/*
- * JPEG image format
- * Copyright (c) 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
- */
-#include "avformat.h"
-
-static int jpeg_probe(AVProbeData *pd)
-{
-    if (pd->buf_size >= 64 &&
-        pd->buf[0] == 0xff && pd->buf[1] == 0xd8 && pd->buf[2] == 0xff)
-        return AVPROBE_SCORE_MAX;
-    else
-        return 0;
-}
-
-typedef struct JpegOpaque {
-    int (*alloc_cb)(void *opaque, AVImageInfo *info);
-    void *opaque;
-    int ret_code;
-} JpegOpaque;
-
-/* called by the codec to allocate the image */
-static int jpeg_get_buffer(AVCodecContext *c, AVFrame *picture)
-{
-    JpegOpaque *jctx = c->opaque;
-    AVImageInfo info1, *info = &info1;
-    int ret, i;
-
-    info->width = c->width;
-    info->height = c->height;
-    switch(c->pix_fmt) {
-    case PIX_FMT_YUV420P:
-        info->pix_fmt = PIX_FMT_YUVJ420P;
-        break;
-    case PIX_FMT_YUV422P:
-        info->pix_fmt = PIX_FMT_YUVJ422P;
-        break;
-    case PIX_FMT_YUV444P:
-        info->pix_fmt = PIX_FMT_YUVJ444P;
-        break;
-    default:
-        return -1;
-    }
-    ret = jctx->alloc_cb(jctx->opaque, info);
-    if (ret) {
-        jctx->ret_code = ret;
-        return -1;
-    } else {
-        for(i=0;i<3;i++) {
-            picture->data[i] = info->pict.data[i];
-            picture->linesize[i] = info->pict.linesize[i];
-        }
-        return 0;
-    }
-}
-
-static void jpeg_img_copy(uint8_t *dst, int dst_wrap,
-                     uint8_t *src, int src_wrap,
-                     int width, int height)
-{
-    for(;height > 0; height--) {
-        memcpy(dst, src, width);
-        dst += dst_wrap;
-        src += src_wrap;
-    }
-}
-
-/* XXX: libavcodec is broken for truncated jpegs! */
-#define IO_BUF_SIZE (1024*1024)
-
-static int jpeg_read(ByteIOContext *f,
-                     int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque)
-{
-    AVCodecContext *c;
-    AVFrame *picture, picture1;
-    int len, size, got_picture, i;
-    uint8_t *inbuf_ptr, inbuf[IO_BUF_SIZE];
-    JpegOpaque jctx;
-
-    jctx.alloc_cb = alloc_cb;
-    jctx.opaque = opaque;
-    jctx.ret_code = -1; /* default return code is error */
-
-    c = avcodec_alloc_context();
-    if (!c)
-        return -1;
-    picture= avcodec_alloc_frame();
-    if (!picture) {
-        av_free(c);
-        return -1;
-    }
-    c->opaque = &jctx;
-    c->get_buffer = jpeg_get_buffer;
-    c->flags |= CODEC_FLAG_TRUNCATED; /* we dont send complete frames */
-    if (avcodec_open(c, &mjpeg_decoder) < 0)
-        goto fail1;
-    for(;;) {
-        size = get_buffer(f, inbuf, sizeof(inbuf));
-        if (size == 0)
-            break;
-        inbuf_ptr = inbuf;
-        while (size > 0) {
-            len = avcodec_decode_video(c, &picture1, &got_picture,
-                                       inbuf_ptr, size);
-            if (len < 0)
-                goto fail;
-            if (got_picture)
-                goto the_end;
-            size -= len;
-            inbuf_ptr += len;
-        }
-    }
- the_end:
-    /* XXX: currently, the mjpeg decoder does not use AVFrame, so we
-       must do it by hand */
-    if (jpeg_get_buffer(c, picture) < 0)
-        goto fail;
-    for(i=0;i<3;i++) {
-        int w, h;
-        w = c->width;
-        h = c->height;
-        if (i >= 1) {
-            switch(c->pix_fmt) {
-            default:
-            case PIX_FMT_YUV420P:
-                w = (w + 1) >> 1;
-                h = (h + 1) >> 1;
-                break;
-            case PIX_FMT_YUV422P:
-                w = (w + 1) >> 1;
-                break;
-            case PIX_FMT_YUV444P:
-                break;
-            }
-        }
-        jpeg_img_copy(picture->data[i], picture->linesize[i],
-                 picture1.data[i], picture1.linesize[i],
-                 w, h);
-    }
-    jctx.ret_code = 0;
- fail:
-    avcodec_close(c);
- fail1:
-    av_free(picture);
-    av_free(c);
-    return jctx.ret_code;
-}
-
-#if defined(CONFIG_MUXERS) && defined(CONFIG_MJPEG_ENCODER)
-static int jpeg_write(ByteIOContext *pb, AVImageInfo *info)
-{
-    AVCodecContext *c;
-    uint8_t *outbuf = NULL;
-    int outbuf_size, ret, size, i;
-    AVFrame *picture;
-
-    ret = -1;
-    c = avcodec_alloc_context();
-    if (!c)
-        return -1;
-    picture = avcodec_alloc_frame();
-    if (!picture)
-        goto fail2;
-    c->width = info->width;
-    c->height = info->height;
-    /* XXX: currently move that to the codec ? */
-    switch(info->pix_fmt) {
-    case PIX_FMT_YUVJ420P:
-        c->pix_fmt = PIX_FMT_YUV420P;
-        break;
-    case PIX_FMT_YUVJ422P:
-        c->pix_fmt = PIX_FMT_YUV422P;
-        break;
-    case PIX_FMT_YUVJ444P:
-        c->pix_fmt = PIX_FMT_YUV444P;
-        break;
-    default:
-        goto fail1;
-    }
-    for(i=0;i<3;i++) {
-        picture->data[i] = info->pict.data[i];
-        picture->linesize[i] = info->pict.linesize[i];
-    }
-    /* set the quality */
-    picture->quality = 3; /* XXX: a parameter should be used */
-    c->flags |= CODEC_FLAG_QSCALE;
-
-    if (avcodec_open(c, &mjpeg_encoder) < 0)
-        goto fail1;
-
-    /* XXX: needs to sort out that size problem */
-    outbuf_size = 1000000;
-    outbuf = av_malloc(outbuf_size);
-
-    size = avcodec_encode_video(c, outbuf, outbuf_size, picture);
-    if (size < 0)
-        goto fail;
-    put_buffer(pb, outbuf, size);
-    put_flush_packet(pb);
-    ret = 0;
-
- fail:
-    avcodec_close(c);
-    av_free(outbuf);
- fail1:
-    av_free(picture);
- fail2:
-    av_free(c);
-    return ret;
-}
-#endif //CONFIG_MUXERS
-
-AVImageFormat jpeg_image_format = {
-    "jpeg",
-    "jpg,jpeg",
-    jpeg_probe,
-    jpeg_read,
-    (1 << PIX_FMT_YUVJ420P) | (1 << PIX_FMT_YUVJ422P) | (1 << PIX_FMT_YUVJ444P),
-#if defined(CONFIG_MUXERS) && defined(CONFIG_MJPEG_ENCODER)
-    jpeg_write,
-#else
-    NULL,
-#endif //CONFIG_MUXERS
-};
--- a/src/ffmpeg/libavformat/png.c	Mon Mar 12 14:37:31 2007 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,889 +0,0 @@
-/*
- * PNG image format
- * Copyright (c) 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
- */
-#include "avformat.h"
-
-/* TODO:
- * - add 2, 4 and 16 bit depth support
- * - use filters when generating a png (better compression)
- */
-
-#ifdef CONFIG_ZLIB
-#include <zlib.h>
-
-//#define DEBUG
-
-#define PNG_COLOR_MASK_PALETTE    1
-#define PNG_COLOR_MASK_COLOR      2
-#define PNG_COLOR_MASK_ALPHA      4
-
-#define PNG_COLOR_TYPE_GRAY 0
-#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
-#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)
-#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
-#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
-
-#define PNG_FILTER_VALUE_NONE  0
-#define PNG_FILTER_VALUE_SUB   1
-#define PNG_FILTER_VALUE_UP    2
-#define PNG_FILTER_VALUE_AVG   3
-#define PNG_FILTER_VALUE_PAETH 4
-
-#define PNG_IHDR      0x0001
-#define PNG_IDAT      0x0002
-#define PNG_ALLIMAGE  0x0004
-#define PNG_PLTE      0x0008
-
-#define NB_PASSES 7
-
-#define IOBUF_SIZE 4096
-
-typedef struct PNGDecodeState {
-    int state;
-    int width, height;
-    int bit_depth;
-    int color_type;
-    int compression_type;
-    int interlace_type;
-    int filter_type;
-    int channels;
-    int bits_per_pixel;
-    int bpp;
-
-    uint8_t *image_buf;
-    int image_linesize;
-    uint32_t palette[256];
-    uint8_t *crow_buf;
-    uint8_t *last_row;
-    uint8_t *tmp_row;
-    int pass;
-    int crow_size; /* compressed row size (include filter type) */
-    int row_size; /* decompressed row size */
-    int pass_row_size; /* decompress row size of the current pass */
-    int y;
-    z_stream zstream;
-} PNGDecodeState;
-
-static const uint8_t pngsig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
-
-/* Mask to determine which y pixels are valid in a pass */
-static const uint8_t png_pass_ymask[NB_PASSES] = {
-    0x80, 0x80, 0x08, 0x88, 0x22, 0xaa, 0x55,
-};
-
-/* Mask to determine which y pixels can be written in a pass */
-static const uint8_t png_pass_dsp_ymask[NB_PASSES] = {
-    0xff, 0xff, 0x0f, 0xcc, 0x33, 0xff, 0x55,
-};
-
-/* minimum x value */
-static const uint8_t png_pass_xmin[NB_PASSES] = {
-    0, 4, 0, 2, 0, 1, 0
-};
-
-/* x shift to get row width */
-static const uint8_t png_pass_xshift[NB_PASSES] = {
-    3, 3, 2, 2, 1, 1, 0
-};
-
-/* Mask to determine which pixels are valid in a pass */
-static const uint8_t png_pass_mask[NB_PASSES] = {
-    0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff
-};
-
-/* Mask to determine which pixels to overwrite while displaying */
-static const uint8_t png_pass_dsp_mask[NB_PASSES] = {
-    0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
-};
-
-static int png_probe(AVProbeData *pd)
-{
-    if (pd->buf_size >= 8 &&
-        memcmp(pd->buf, pngsig, 8) == 0)
-        return AVPROBE_SCORE_MAX;
-    else
-        return 0;
-}
-
-static void *png_zalloc(void *opaque, unsigned int items, unsigned int size)
-{
-    return av_malloc(items * size);
-}
-
-static void png_zfree(void *opaque, void *ptr)
-{
-    av_free(ptr);
-}
-
-static int png_get_nb_channels(int color_type)
-{
-    int channels;
-    channels = 1;
-    if ((color_type & (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)) ==
-        PNG_COLOR_MASK_COLOR)
-        channels = 3;
-    if (color_type & PNG_COLOR_MASK_ALPHA)
-        channels++;
-    return channels;
-}
-
-/* compute the row size of an interleaved pass */
-static int png_pass_row_size(int pass, int bits_per_pixel, int width)
-{
-    int shift, xmin, pass_width;
-
-    xmin = png_pass_xmin[pass];
-    if (width <= xmin)
-        return 0;
-    shift = png_pass_xshift[pass];
-    pass_width = (width - xmin + (1 << shift) - 1) >> shift;
-    return (pass_width * bits_per_pixel + 7) >> 3;
-}
-
-/* NOTE: we try to construct a good looking image at each pass. width
-   is the original image width. We also do pixel format convertion at
-   this stage */
-static void png_put_interlaced_row(uint8_t *dst, int width,
-                                   int bits_per_pixel, int pass,
-                                   int color_type, const uint8_t *src)
-{
-    int x, mask, dsp_mask, j, src_x, b, bpp;
-    uint8_t *d;
-    const uint8_t *s;
-
-    mask = png_pass_mask[pass];
-    dsp_mask = png_pass_dsp_mask[pass];
-    switch(bits_per_pixel) {
-    case 1:
-        /* we must intialize the line to zero before writing to it */
-        if (pass == 0)
-            memset(dst, 0, (width + 7) >> 3);
-        src_x = 0;
-        for(x = 0; x < width; x++) {
-            j = (x & 7);
-            if ((dsp_mask << j) & 0x80) {
-                b = (src[src_x >> 3] >> (7 - (src_x & 7))) & 1;
-                dst[x >> 3] |= b << (7 - j);
-            }
-            if ((mask << j) & 0x80)
-                src_x++;
-        }
-        break;
-    default:
-        bpp = bits_per_pixel >> 3;
-        d = dst;
-        s = src;
-        if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
-            for(x = 0; x < width; x++) {
-                j = x & 7;
-                if ((dsp_mask << j) & 0x80) {
-                    *(uint32_t *)d = (s[3] << 24) | (s[0] << 16) | (s[1] << 8) | s[2];
-                }
-                d += bpp;
-                if ((mask << j) & 0x80)
-                    s += bpp;
-            }
-        } else {
-            for(x = 0; x < width; x++) {
-                j = x & 7;
-                if ((dsp_mask << j) & 0x80) {
-                    memcpy(d, s, bpp);
-                }
-                d += bpp;
-                if ((mask << j) & 0x80)
-                    s += bpp;
-            }
-        }
-        break;
-    }
-}
-
-static void png_get_interlaced_row(uint8_t *dst, int row_size,
-                                   int bits_per_pixel, int pass,
-                                   const uint8_t *src, int width)
-{
-    int x, mask, dst_x, j, b, bpp;
-    uint8_t *d;
-    const uint8_t *s;
-
-    mask = png_pass_mask[pass];
-    switch(bits_per_pixel) {
-    case 1:
-        memset(dst, 0, row_size);
-        dst_x = 0;
-        for(x = 0; x < width; x++) {
-            j = (x & 7);
-            if ((mask << j) & 0x80) {
-                b = (src[x >> 3] >> (7 - j)) & 1;
-                dst[dst_x >> 3] |= b << (7 - (dst_x & 7));
-                dst_x++;
-            }
-        }
-        break;
-    default:
-        bpp = bits_per_pixel >> 3;
-        d = dst;
-        s = src;
-        for(x = 0; x < width; x++) {
-            j = x & 7;
-            if ((mask << j) & 0x80) {
-                memcpy(d, s, bpp);
-                d += bpp;
-            }
-            s += bpp;
-        }
-        break;
-    }
-}
-
-/* XXX: optimize */
-/* NOTE: 'dst' can be equal to 'last' */
-static void png_filter_row(uint8_t *dst, int filter_type,
-                           uint8_t *src, uint8_t *last, int size, int bpp)
-{
-    int i, p;
-
-    switch(filter_type) {
-    case PNG_FILTER_VALUE_NONE:
-        memcpy(dst, src, size);
-        break;
-    case PNG_FILTER_VALUE_SUB:
-        for(i = 0; i < bpp; i++) {
-            dst[i] = src[i];
-        }
-        for(i = bpp; i < size; i++) {
-            p = dst[i - bpp];
-            dst[i] = p + src[i];
-        }
-        break;
-    case PNG_FILTER_VALUE_UP:
-        for(i = 0; i < size; i++) {
-            p = last[i];
-            dst[i] = p + src[i];
-        }
-        break;
-    case PNG_FILTER_VALUE_AVG:
-        for(i = 0; i < bpp; i++) {
-            p = (last[i] >> 1);
-            dst[i] = p + src[i];
-        }
-        for(i = bpp; i < size; i++) {
-            p = ((dst[i - bpp] + last[i]) >> 1);
-            dst[i] = p + src[i];
-        }
-        break;
-    case PNG_FILTER_VALUE_PAETH:
-        for(i = 0; i < bpp; i++) {
-            p = last[i];
-            dst[i] = p + src[i];
-        }
-        for(i = bpp; i < size; i++) {
-            int a, b, c, pa, pb, pc;
-
-            a = dst[i - bpp];
-            b = last[i];
-            c = last[i - bpp];
-
-            p = b - c;
-            pc = a - c;
-
-            pa = abs(p);
-            pb = abs(pc);
-            pc = abs(p + pc);
-
-            if (pa <= pb && pa <= pc)
-                p = a;
-            else if (pb <= pc)
-                p = b;
-            else
-                p = c;
-            dst[i] = p + src[i];
-        }
-        break;
-    }
-}
-
-static void convert_from_rgba32(uint8_t *dst, const uint8_t *src, int width)
-{
-    uint8_t *d;
-    int j;
-    unsigned int v;
-
-    d = dst;
-    for(j = 0; j < width; j++) {
-        v = ((const uint32_t *)src)[j];
-        d[0] = v >> 16;
-        d[1] = v >> 8;
-        d[2] = v;
-        d[3] = v >> 24;
-        d += 4;
-    }
-}
-
-static void convert_to_rgba32(uint8_t *dst, const uint8_t *src, int width)
-{
-    int j;
-    unsigned int r, g, b, a;
-
-    for(j = 0;j < width; j++) {
-        r = src[0];
-        g = src[1];
-        b = src[2];
-        a = src[3];
-        *(uint32_t *)dst = (a << 24) | (r << 16) | (g << 8) | b;
-        dst += 4;
-        src += 4;
-    }
-}
-
-/* process exactly one decompressed row */
-static void png_handle_row(PNGDecodeState *s)
-{
-    uint8_t *ptr, *last_row;
-    int got_line;
-
-    if (!s->interlace_type) {
-        ptr = s->image_buf + s->image_linesize * s->y;
-        /* need to swap bytes correctly for RGB_ALPHA */
-        if (s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
-            png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
-                           s->last_row, s->row_size, s->bpp);
-            memcpy(s->last_row, s->tmp_row, s->row_size);
-            convert_to_rgba32(ptr, s->tmp_row, s->width);
-        } else {
-            /* in normal case, we avoid one copy */
-            if (s->y == 0)
-                last_row = s->last_row;
-            else
-                last_row = ptr - s->image_linesize;
-
-            png_filter_row(ptr, s->crow_buf[0], s->crow_buf + 1,
-                           last_row, s->row_size, s->bpp);
-        }
-        s->y++;
-        if (s->y == s->height) {
-            s->state |= PNG_ALLIMAGE;
-        }
-    } else {
-        got_line = 0;
-        for(;;) {
-            ptr = s->image_buf + s->image_linesize * s->y;
-            if ((png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {
-                /* if we already read one row, it is time to stop to
-                   wait for the next one */
-                if (got_line)
-                    break;
-                png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
-                               s->last_row, s->pass_row_size, s->bpp);
-                memcpy(s->last_row, s->tmp_row, s->pass_row_size);
-                got_line = 1;
-            }
-            if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {
-                /* NOTE: rgba32 is handled directly in png_put_interlaced_row */
-                png_put_interlaced_row(ptr, s->width, s->bits_per_pixel, s->pass,
-                                       s->color_type, s->last_row);
-            }
-            s->y++;
-            if (s->y == s->height) {
-                for(;;) {
-                    if (s->pass == NB_PASSES - 1) {
-                        s->state |= PNG_ALLIMAGE;
-                        goto the_end;
-                    } else {
-                        s->pass++;
-                        s->y = 0;
-                        s->pass_row_size = png_pass_row_size(s->pass,
-                                                             s->bits_per_pixel,
-                                                             s->width);
-                        s->crow_size = s->pass_row_size + 1;
-                        if (s->pass_row_size != 0)
-                            break;
-                        /* skip pass if empty row */
-                    }
-                }
-            }
-        }
-    the_end: ;
-    }
-}
-
-static int png_decode_idat(PNGDecodeState *s, ByteIOContext *f, int length)
-{
-    uint8_t buf[IOBUF_SIZE];
-    int buf_size;
-    int ret;
-    while (length > 0) {
-        /* read the buffer */
-        buf_size = IOBUF_SIZE;
-        if (buf_size > length)
-            buf_size = length;
-        ret = get_buffer(f, buf, buf_size);
-        if (ret != buf_size)
-            return -1;
-        s->zstream.avail_in = buf_size;
-        s->zstream.next_in = buf;
-        /* decode one line if possible */
-        while (s->zstream.avail_in > 0) {
-            ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
-            if (ret != Z_OK && ret != Z_STREAM_END) {
-                return -1;
-            }
-            if (s->zstream.avail_out == 0) {
-                if (!(s->state & PNG_ALLIMAGE)) {
-                    png_handle_row(s);
-                }
-                s->zstream.avail_out = s->crow_size;
-                s->zstream.next_out = s->crow_buf;
-            }
-        }
-        length -= buf_size;
-    }
-    return 0;
-}
-
-static int png_read(ByteIOContext *f,
-                    int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque)
-{
-    AVImageInfo info1, *info = &info1;
-    PNGDecodeState s1, *s = &s1;
-    uint32_t tag, length;
-    int ret, crc;
-    uint8_t buf[8];
-
-    /* check signature */
-    ret = get_buffer(f, buf, 8);
-    if (ret != 8)
-        return -1;
-    if (memcmp(buf, pngsig, 8) != 0)
-        return -1;
-    memset(s, 0, sizeof(PNGDecodeState));
-    /* init the zlib */
-    s->zstream.zalloc = png_zalloc;
-    s->zstream.zfree = png_zfree;
-    s->zstream.opaque = NULL;
-    ret = inflateInit(&s->zstream);
-    if (ret != Z_OK)
-        return -1;
-    for(;;) {
-        if (url_feof(f))
-            goto fail;
-        length = get_be32(f);
-        if (length > 0x7fffffff)
-            goto fail;
-        tag = get_le32(f);
-#ifdef DEBUG
-        printf("png: tag=%c%c%c%c length=%u\n",
-               (tag & 0xff),
-               ((tag >> 8) & 0xff),
-               ((tag >> 16) & 0xff),
-               ((tag >> 24) & 0xff), length);
-#endif
-        switch(tag) {
-        case MKTAG('I', 'H', 'D', 'R'):
-            if (length != 13)
-                goto fail;
-            s->width = get_be32(f);
-            s->height = get_be32(f);
-            s->bit_depth = get_byte(f);
-            s->color_type = get_byte(f);
-            s->compression_type = get_byte(f);
-            s->filter_type = get_byte(f);
-            s->interlace_type = get_byte(f);
-            crc = get_be32(f);
-            s->state |= PNG_IHDR;
-#ifdef DEBUG
-            printf("width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
-                   s->width, s->height, s->bit_depth, s->color_type,
-                   s->compression_type, s->filter_type, s->interlace_type);
-#endif
-            break;
-        case MKTAG('I', 'D', 'A', 'T'):
-            if (!(s->state & PNG_IHDR))
-                goto fail;
-            if (!(s->state & PNG_IDAT)) {
-                /* init image info */
-                info->width = s->width;
-                info->height = s->height;
-                info->interleaved = (s->interlace_type != 0);
-
-                s->channels = png_get_nb_channels(s->color_type);
-                s->bits_per_pixel = s->bit_depth * s->channels;
-                s->bpp = (s->bits_per_pixel + 7) >> 3;
-                s->row_size = (info->width * s->bits_per_pixel + 7) >> 3;
-
-                if (s->bit_depth == 8 &&
-                    s->color_type == PNG_COLOR_TYPE_RGB) {
-                    info->pix_fmt = PIX_FMT_RGB24;
-                } else if (s->bit_depth == 8 &&
-                           s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
-                    info->pix_fmt = PIX_FMT_RGBA32;
-                } else if (s->bit_depth == 8 &&
-                           s->color_type == PNG_COLOR_TYPE_GRAY) {
-                    info->pix_fmt = PIX_FMT_GRAY8;
-                } else if (s->bit_depth == 1 &&
-                           s->color_type == PNG_COLOR_TYPE_GRAY) {
-                    info->pix_fmt = PIX_FMT_MONOBLACK;
-                } else if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
-                    info->pix_fmt = PIX_FMT_PAL8;
-                } else {
-                    goto fail;
-                }
-                ret = alloc_cb(opaque, info);
-                if (ret)
-                    goto the_end;
-
-                /* compute the compressed row size */
-                if (!s->interlace_type) {
-                    s->crow_size = s->row_size + 1;
-                } else {
-                    s->pass = 0;
-                    s->pass_row_size = png_pass_row_size(s->pass,
-                                                         s->bits_per_pixel,
-                                                         s->width);
-                    s->crow_size = s->pass_row_size + 1;
-                }
-#ifdef DEBUG
-                printf("row_size=%d crow_size =%d\n",
-                       s->row_size, s->crow_size);
-#endif
-                s->image_buf = info->pict.data[0];
-                s->image_linesize = info->pict.linesize[0];
-                /* copy the palette if needed */
-                if (s->color_type == PNG_COLOR_TYPE_PALETTE)
-                    memcpy(info->pict.data[1], s->palette, 256 * sizeof(uint32_t));
-                /* empty row is used if differencing to the first row */
-                s->last_row = av_mallocz(s->row_size);
-                if (!s->last_row)
-                    goto fail;
-                if (s->interlace_type ||
-                    s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
-                    s->tmp_row = av_malloc(s->row_size);
-                    if (!s->tmp_row)
-                        goto fail;
-                }
-                /* compressed row */
-                s->crow_buf = av_malloc(s->row_size + 1);
-                if (!s->crow_buf)
-                    goto fail;
-                s->zstream.avail_out = s->crow_size;
-                s->zstream.next_out = s->crow_buf;
-            }
-            s->state |= PNG_IDAT;
-            if (png_decode_idat(s, f, length) < 0)
-                goto fail;
-            /* skip crc */
-            crc = get_be32(f);
-            break;
-        case MKTAG('P', 'L', 'T', 'E'):
-            {
-                int n, i, r, g, b;
-
-                if ((length % 3) != 0 || length > 256 * 3)
-                    goto skip_tag;
-                /* read the palette */
-                n = length / 3;
-                for(i=0;i<n;i++) {
-                    r = get_byte(f);
-                    g = get_byte(f);
-                    b = get_byte(f);
-                    s->palette[i] = (0xff << 24) | (r << 16) | (g << 8) | b;
-                }
-                for(;i<256;i++) {
-                    s->palette[i] = (0xff << 24);
-                }
-                s->state |= PNG_PLTE;
-                crc = get_be32(f);
-            }
-            break;
-        case MKTAG('t', 'R', 'N', 'S'):
-            {
-                int v, i;
-
-                /* read the transparency. XXX: Only palette mode supported */
-                if (s->color_type != PNG_COLOR_TYPE_PALETTE ||
-                    length > 256 ||
-                    !(s->state & PNG_PLTE))
-                    goto skip_tag;
-                for(i=0;i<length;i++) {
-                    v = get_byte(f);
-                    s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
-                }
-                crc = get_be32(f);
-            }
-            break;
-        case MKTAG('I', 'E', 'N', 'D'):
-            if (!(s->state & PNG_ALLIMAGE))
-                goto fail;
-            crc = get_be32(f);
-            goto exit_loop;
-        default:
-            /* skip tag */
-        skip_tag:
-            url_fskip(f, length + 4);
-            break;
-        }
-    }
- exit_loop:
-    ret = 0;
- the_end:
-    inflateEnd(&s->zstream);
-    av_free(s->crow_buf);
-    av_free(s->last_row);
-    av_free(s->tmp_row);
-    return ret;
- fail:
-    ret = -1;
-    goto the_end;
-}
-
-static void png_write_chunk(ByteIOContext *f, uint32_t tag,
-                            const uint8_t *buf, int length)
-{
-    uint32_t crc;
-    uint8_t tagbuf[4];
-
-    put_be32(f, length);
-    crc = crc32(0, Z_NULL, 0);
-    tagbuf[0] = tag;
-    tagbuf[1] = tag >> 8;
-    tagbuf[2] = tag >> 16;
-    tagbuf[3] = tag >> 24;
-    crc = crc32(crc, tagbuf, 4);
-    put_le32(f, tag);
-    if (length > 0) {
-        crc = crc32(crc, buf, length);
-        put_buffer(f, buf, length);
-    }
-    put_be32(f, crc);
-}
-
-/* XXX: use avcodec generic function ? */
-static void to_be32(uint8_t *p, uint32_t v)
-{
-    p[0] = v >> 24;
-    p[1] = v >> 16;
-    p[2] = v >> 8;
-    p[3] = v;
-}
-
-typedef struct PNGEncodeState {
-    ByteIOContext *f;
-    z_stream zstream;
-    uint8_t buf[IOBUF_SIZE];
-} PNGEncodeState;
-
-
-/* XXX: do filtering */
-static int png_write_row(PNGEncodeState *s, const uint8_t *data, int size)
-{
-    int ret;
-
-    s->zstream.avail_in = size;
-    s->zstream.next_in = (uint8_t *)data;
-    while (s->zstream.avail_in > 0) {
-        ret = deflate(&s->zstream, Z_NO_FLUSH);
-        if (ret != Z_OK)
-            return -1;
-        if (s->zstream.avail_out == 0) {
-            png_write_chunk(s->f, MKTAG('I', 'D', 'A', 'T'), s->buf, IOBUF_SIZE);
-            s->zstream.avail_out = IOBUF_SIZE;
-            s->zstream.next_out = s->buf;
-        }
-    }
-    return 0;
-}
-
-static int png_write(ByteIOContext *f, AVImageInfo *info)
-{
-    PNGEncodeState s1, *s = &s1;
-    int bit_depth, color_type, y, len, row_size, ret, is_progressive;
-    int bits_per_pixel, pass_row_size;
-    uint8_t *ptr;
-    uint8_t *crow_buf = NULL;
-    uint8_t *tmp_buf = NULL;
-
-    s->f = f;
-    is_progressive = info->interleaved;
-    switch(info->pix_fmt) {
-    case PIX_FMT_RGBA32:
-        bit_depth = 8;
-        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
-        break;
-    case PIX_FMT_RGB24:
-        bit_depth = 8;
-        color_type = PNG_COLOR_TYPE_RGB;
-        break;
-    case PIX_FMT_GRAY8:
-        bit_depth = 8;
-        color_type = PNG_COLOR_TYPE_GRAY;
-        break;
-    case PIX_FMT_MONOBLACK:
-        bit_depth = 1;
-        color_type = PNG_COLOR_TYPE_GRAY;
-        break;
-    case PIX_FMT_PAL8:
-        bit_depth = 8;
-        color_type = PNG_COLOR_TYPE_PALETTE;
-        break;
-    default:
-        return -1;
-    }
-    bits_per_pixel = png_get_nb_channels(color_type) * bit_depth;
-    row_size = (info->width * bits_per_pixel + 7) >> 3;
-
-    s->zstream.zalloc = png_zalloc;
-    s->zstream.zfree = png_zfree;
-    s->zstream.opaque = NULL;
-    ret = deflateInit2(&s->zstream, Z_DEFAULT_COMPRESSION,
-                       Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY);
-    if (ret != Z_OK)
-        return -1;
-    crow_buf = av_malloc(row_size + 1);
-    if (!crow_buf)
-        goto fail;
-    if (is_progressive) {
-        tmp_buf = av_malloc(row_size + 1);
-        if (!tmp_buf)
-            goto fail;
-    }
-
-    /* write png header */
-    put_buffer(f, pngsig, 8);
-
-    to_be32(s->buf, info->width);
-    to_be32(s->buf + 4, info->height);
-    s->buf[8] = bit_depth;
-    s->buf[9] = color_type;
-    s->buf[10] = 0; /* compression type */
-    s->buf[11] = 0; /* filter type */
-    s->buf[12] = is_progressive; /* interlace type */
-
-    png_write_chunk(f, MKTAG('I', 'H', 'D', 'R'), s->buf, 13);
-
-    /* put the palette if needed */
-    if (color_type == PNG_COLOR_TYPE_PALETTE) {
-        int has_alpha, alpha, i;
-        unsigned int v;
-        uint32_t *palette;
-        uint8_t *alpha_ptr;
-
-        palette = (uint32_t *)info->pict.data[1];
-        ptr = s->buf;
-        alpha_ptr = s->buf + 256 * 3;
-        has_alpha = 0;
-        for(i = 0; i < 256; i++) {
-            v = palette[i];
-            alpha = v >> 24;
-            if (alpha != 0xff)
-                has_alpha = 1;
-            *alpha_ptr++ = alpha;
-            ptr[0] = v >> 16;
-            ptr[1] = v >> 8;
-            ptr[2] = v;
-            ptr += 3;
-        }
-        png_write_chunk(f, MKTAG('P', 'L', 'T', 'E'), s->buf, 256 * 3);
-        if (has_alpha) {
-            png_write_chunk(f, MKTAG('t', 'R', 'N', 'S'), s->buf + 256 * 3, 256);
-        }
-    }
-
-    /* now put each row */
-    s->zstream.avail_out = IOBUF_SIZE;
-    s->zstream.next_out = s->buf;
-    if (is_progressive) {
-        uint8_t *ptr1;
-        int pass;
-
-        for(pass = 0; pass < NB_PASSES; pass++) {
-            /* NOTE: a pass is completely omited if no pixels would be
-               output */
-            pass_row_size = png_pass_row_size(pass, bits_per_pixel, info->width);
-            if (pass_row_size > 0) {
-                for(y = 0; y < info->height; y++) {
-                    if ((png_pass_ymask[pass] << (y & 7)) & 0x80) {
-                        ptr = info->pict.data[0] + y * info->pict.linesize[0];
-                        if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
-                            convert_from_rgba32(tmp_buf, ptr, info->width);
-                            ptr1 = tmp_buf;
-                        } else {
-                            ptr1 = ptr;
-                        }
-                        png_get_interlaced_row(crow_buf + 1, pass_row_size,
-                                               bits_per_pixel, pass,
-                                               ptr1, info->width);
-                        crow_buf[0] = PNG_FILTER_VALUE_NONE;
-                        png_write_row(s, crow_buf, pass_row_size + 1);
-                    }
-                }
-            }
-        }
-    } else {
-        for(y = 0; y < info->height; y++) {
-            ptr = info->pict.data[0] + y * info->pict.linesize[0];
-            if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-                convert_from_rgba32(crow_buf + 1, ptr, info->width);
-            else
-                memcpy(crow_buf + 1, ptr, row_size);
-            crow_buf[0] = PNG_FILTER_VALUE_NONE;
-            png_write_row(s, crow_buf, row_size + 1);
-        }
-    }
-    /* compress last bytes */
-    for(;;) {
-        ret = deflate(&s->zstream, Z_FINISH);
-        if (ret == Z_OK || ret == Z_STREAM_END) {
-            len = IOBUF_SIZE - s->zstream.avail_out;
-            if (len > 0) {
-                png_write_chunk(f, MKTAG('I', 'D', 'A', 'T'), s->buf, len);
-            }
-            s->zstream.avail_out = IOBUF_SIZE;
-            s->zstream.next_out = s->buf;
-            if (ret == Z_STREAM_END)
-                break;
-        } else {
-            goto fail;
-        }
-    }
-    png_write_chunk(f, MKTAG('I', 'E', 'N', 'D'), NULL, 0);
-
-    put_flush_packet(f);
-    ret = 0;
- the_end:
-    av_free(crow_buf);
-    av_free(tmp_buf);
-    deflateEnd(&s->zstream);
-    return ret;
- fail:
-    ret = -1;
-    goto the_end;
-}
-
-AVImageFormat png_image_format = {
-    "png",
-    "png",
-    png_probe,
-    png_read,
-    (1 << PIX_FMT_RGBA32) | (1 << PIX_FMT_RGB24) | (1 << PIX_FMT_GRAY8) |
-    (1 << PIX_FMT_MONOBLACK) | (1 << PIX_FMT_PAL8),
-    png_write,
-    AVIMAGE_INTERLEAVED,
-};
-#endif