@@ -205,7 +205,6 @@ External library support:

   --enable-libxvid         enable Xvid encoding via xvidcore,

                            native MPEG-4/Xvid encoder exists [no]

   --enable-openal          enable OpenAL 1.1 capture support [no]

-  --enable-mlib            enable Sun medialib [no]

   --enable-openssl         enable openssl [no]

   --enable-zlib            enable zlib [autodetect]

@@ -1062,7 +1061,6 @@ CONFIG_LIST="

     lsp

     mdct

     memalign_hack

-    mlib

     mpegaudiodsp

     network

     nonfree

@@ -3179,7 +3177,6 @@ enabled openal     && { { for al_libs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32

                         die "ERROR: openal not found"; } &&

                       { check_cpp_condition "AL/al.h" "defined(AL_VERSION_1_1)" ||

                         die "ERROR: openal version must be 1.1 or compatible"; }

-enabled mlib       && require  mediaLib mlib_types.h mlib_VectorSub_S16_U8_Mod -lmlib

 enabled openssl    && { check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto ||

                         check_lib openssl/ssl.h SSL_library_init -lssl32 -leay32 ||

                         check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||

@@ -3478,7 +3475,6 @@ echo "network support           ${network-no}"

 echo "threading support         ${thread_type-no}"

 echo "safe bitstream reader     ${safe_bitstream_reader-no}"

 echo "SDL support               ${sdl-no}"

-echo "Sun medialib support      ${mlib-no}"

 echo "libdxva2 enabled          ${dxva2-no}"

 echo "libva enabled             ${vaapi-no}"

 echo "libvdpau enabled          ${vdpau-no}"

@@ -25,6 +25,12 @@ API changes, most recent first:

 2012-01-24 - xxxxxxx - lavfi 2.60.100

   Add avfilter_graph_dump.

+2012-02-xx - xxxxxxx - lavu 51.22.1 - pixdesc.h

+  Add PIX_FMT_PSEUDOPAL flag.

+

+2012-02-01 - xxxxxxx - lavc 54.01.0

+  Add avcodec_encode_video2() and deprecate avcodec_encode_video().

+

 2012-02-01 - 316fc74 - lavc 54.01.0

   Add av_fast_padded_malloc() as alternative for av_realloc() when aligned

   memory is required. The buffer will always have FF_INPUT_BUFFER_PADDING_SIZE

@@ -1385,9 +1385,6 @@ static void do_subtitle_out(AVFormatContext *s,

     }

 }

-static int bit_buffer_size = 1024 * 256;

-static uint8_t *bit_buffer = NULL;

-

 static void do_video_resample(OutputStream *ost,

                               InputStream *ist,

                               AVFrame *in_picture,

@@ -1513,6 +1510,8 @@ static void do_video_out(AVFormatContext *s,

     for (i = 0; i < nb_frames; i++) {

         AVPacket pkt;

         av_init_packet(&pkt);

+        pkt.data = NULL;

+        pkt.size = 0;

         if (s->oformat->flags & AVFMT_RAWPICTURE &&

             enc->codec->id == CODEC_ID_RAWVIDEO) {

@@ -1528,6 +1527,7 @@ static void do_video_out(AVFormatContext *s,

             write_frame(s, &pkt, ost);

         } else {

+            int got_packet;

             AVFrame big_picture;

             big_picture = *final_picture;

@@ -1552,29 +1552,27 @@ static void do_video_out(AVFormatContext *s,

                 big_picture.pict_type = AV_PICTURE_TYPE_I;

                 ost->forced_kf_index++;

             }

-            ret = avcodec_encode_video(enc,

-                                       bit_buffer, bit_buffer_size,

-                                       &big_picture);

+            ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);

             if (ret < 0) {

                 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");

                 exit_program(1);

             }

-            if (ret > 0) {

-                pkt.data = bit_buffer;

-                pkt.size = ret;

-                if (!(enc->codec->capabilities & CODEC_CAP_DELAY))

-                    pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);

-                if (enc->coded_frame->pts != AV_NOPTS_VALUE)

-                    pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

+            if (got_packet) {

+                if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))

+                    pkt.pts = ost->sync_opts;

+

+                if (pkt.pts != AV_NOPTS_VALUE)

+                    pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);

+                if (pkt.dts != AV_NOPTS_VALUE)

+                    pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);

-                if (enc->coded_frame->key_frame)

-                    pkt.flags |= AV_PKT_FLAG_KEY;

                 if (format_video_sync == VSYNC_DROP)

                     pkt.pts = pkt.dts = AV_NOPTS_VALUE;

+

                 write_frame(s, &pkt, ost);

-                *frame_size = ret;

-                video_size += ret;

+                *frame_size = pkt.size;

+                video_size += pkt.size;

                 /* if two pass, output log */

                 if (ost->logfile && enc->stats_out) {

@@ -1789,7 +1787,7 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

         for (;;) {

             AVPacket pkt;

-            int fifo_bytes;

+            int fifo_bytes, got_packet;

             av_init_packet(&pkt);

             pkt.data = NULL;

             pkt.size = 0;

@@ -1822,25 +1820,23 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

                 }

                 break;

             case AVMEDIA_TYPE_VIDEO:

-                ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);

+                ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);

                 if (ret < 0) {

                     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");

                     exit_program(1);

                 }

-                video_size += ret;

-                if (enc->coded_frame && enc->coded_frame->key_frame)

-                    pkt.flags |= AV_PKT_FLAG_KEY;

+                video_size += pkt.size;

                 if (ost->logfile && enc->stats_out) {

                     fprintf(ost->logfile, "%s", enc->stats_out);

                 }

-                if (ret <= 0) {

+                if (!got_packet) {

                     stop_encoding = 1;

                     break;

                 }

-                pkt.data = bit_buffer;

-                pkt.size = ret;

-                if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

-                    pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

+                if (pkt.pts != AV_NOPTS_VALUE)

+                    pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);

+                if (pkt.dts != AV_NOPTS_VALUE)

+                    pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);

                 write_frame(os, &pkt, ost);

                 break;

             default:

@@ -2668,19 +2664,6 @@ static int transcode_init(OutputFile *output_files, int nb_output_files,

                 }

             }

         }

-        if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {

-            /* maximum video buffer size is 8-bytes per pixel, plus DPX header size (1664)*/

-            int size        = codec->width * codec->height;

-            bit_buffer_size = FFMAX(bit_buffer_size, 9*size + 10000);

-        }

-    }

-

-    if (!bit_buffer)

-        bit_buffer = av_malloc(bit_buffer_size);

-    if (!bit_buffer) {

-        av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",

-               bit_buffer_size);

-        return AVERROR(ENOMEM);

     }

     /* open each encoder */

@@ -3118,7 +3101,6 @@ static int transcode(OutputFile *output_files, int nb_output_files,

     ret = 0;

  fail:

-    av_freep(&bit_buffer);

     av_freep(&no_packet);

     if (output_streams) {

@@ -718,8 +718,6 @@ OBJS-$(HAVE_PTHREADS)                  += pthread.o

 OBJS-$(HAVE_W32THREADS)                += pthread.o

 OBJS-$(HAVE_OS2THREADS)                += pthread.o

-OBJS-$(CONFIG_MLIB)                    += mlib/dsputil_mlib.o           \

-

 # inverse.o contains the ff_inverse table definition, which is used by

 # the FASTDIV macro (from libavutil); since referencing the external

 # table has a negative effect on performance, copy it in libavcodec as

@@ -749,7 +747,7 @@ HOSTPROGS = aac_tablegen aacps_tablegen cbrt_tablegen cos_tablegen      \

             dv_tablegen motionpixels_tablegen mpegaudio_tablegen        \

             pcm_tablegen qdm2_tablegen sinewin_tablegen

-DIRS = alpha arm bfin mlib ppc ps2 sh4 sparc x86

+DIRS = alpha arm bfin ppc ps2 sh4 sparc x86

 CLEANFILES = *_tables.c *_tables.h *_tablegen$(HOSTEXESUF)

@@ -189,10 +189,10 @@ static int count_channels(enum ChannelPosition che_pos[4][MAX_ELEM_ID])

  * @return  Returns error status. 0 - OK, !0 - error

  */

 static av_cold int che_configure(AACContext *ac,

-                                 enum ChannelPosition che_pos[4][MAX_ELEM_ID],

+                                 enum ChannelPosition che_pos,

                                  int type, int id, int *channels)

 {

-    if (che_pos[type][id]) {

+    if (che_pos) {

         if (!ac->che[type][id]) {

             if (!(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))

                 return AVERROR(ENOMEM);

@@ -222,22 +222,21 @@ static av_cold int che_configure(AACContext *ac,

  * @return  Returns error status. 0 - OK, !0 - error

  */

 static av_cold int output_configure(AACContext *ac,

-                                    enum ChannelPosition che_pos[4][MAX_ELEM_ID],

                                     enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],

                                     int channel_config, enum OCStatus oc_type)

 {

     AVCodecContext *avctx = ac->avctx;

     int i, type, channels = 0, ret;

-    if (new_che_pos != che_pos)

-    memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));

+    if (new_che_pos)

+        memcpy(ac->che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));

     if (channel_config) {

         for (i = 0; i < tags_per_config[channel_config]; i++) {

-            if ((ret = che_configure(ac, che_pos,

-                                     aac_channel_layout_map[channel_config - 1][i][0],

-                                     aac_channel_layout_map[channel_config - 1][i][1],

-                                     &channels)))

+            int id = aac_channel_layout_map[channel_config - 1][i][1];

+            type = aac_channel_layout_map[channel_config - 1][i][0];

+            if ((ret = che_configure(ac, ac->che_pos[type][id],

+                                     type, id, &channels)))

                 return ret;

         }

@@ -249,14 +248,12 @@ static av_cold int output_configure(AACContext *ac,

          * current program configuration.

          *

          * Set up default 1:1 output mapping.

-         *

-         * For a 5.1 stream the output order will be:

-         *    [ Center ] [ Front Left ] [ Front Right ] [ LFE ] [ Surround Left ] [ Surround Right ]

          */

         for (i = 0; i < MAX_ELEM_ID; i++) {

             for (type = 0; type < 4; type++) {

-                if ((ret = che_configure(ac, che_pos, type, i, &channels)))

+                if ((ret = che_configure(ac, ac->che_pos[type][i],

+                                         type, i, &channels)))

                     return ret;

             }

         }

@@ -456,7 +453,7 @@ static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,

     } else if (m4ac->sbr == 1 && m4ac->ps == -1)

         m4ac->ps = 1;

-    if (ac && (ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR)))

+    if (ac && (ret = output_configure(ac, new_che_pos, channel_config, OC_GLOBAL_HDR)))

         return ret;

     if (extension_flag) {

@@ -629,7 +626,7 @@ static av_cold int aac_decode_init(AVCodecContext *avctx)

         if (ac->m4ac.chan_config) {

             int ret = set_default_channel_config(avctx, new_che_pos, ac->m4ac.chan_config);

             if (!ret)

-                output_configure(ac, ac->che_pos, new_che_pos, ac->m4ac.chan_config, OC_GLOBAL_HDR);

+                output_configure(ac, new_che_pos, ac->m4ac.chan_config, OC_GLOBAL_HDR);

             else if (avctx->err_recognition & AV_EF_EXPLODE)

                 return AVERROR_INVALIDDATA;

         }

@@ -1733,7 +1730,7 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,

         } else if (ac->m4ac.ps == -1 && ac->output_configured < OC_LOCKED && ac->avctx->channels == 1) {

             ac->m4ac.sbr = 1;

             ac->m4ac.ps = 1;

-            output_configure(ac, ac->che_pos, ac->che_pos, ac->m4ac.chan_config, ac->output_configured);

+            output_configure(ac, NULL, ac->m4ac.chan_config, ac->output_configured);

         } else {

             ac->m4ac.sbr = 1;

         }

@@ -2116,7 +2113,7 @@ static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)

             ac->m4ac.chan_config = hdr_info.chan_config;

             if (set_default_channel_config(ac->avctx, new_che_pos, hdr_info.chan_config))

                 return -7;

-            if (output_configure(ac, ac->che_pos, new_che_pos, hdr_info.chan_config,

+            if (output_configure(ac, new_che_pos, hdr_info.chan_config,

                                  FFMAX(ac->output_configured, OC_TRIAL_FRAME)))

                 return -7;

         } else if (ac->output_configured != OC_LOCKED) {

@@ -2176,7 +2173,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,

                 if (set_default_channel_config(ac->avctx, new_che_pos, 2)<0)

                     return -1;

-                if (output_configure(ac, ac->che_pos, new_che_pos, 2, OC_TRIAL_FRAME)<0)

+                if (output_configure(ac, new_che_pos, 2, OC_TRIAL_FRAME)<0)

                     return -1;

             }

             if (!(che=get_che(ac, elem_type, elem_id))) {

@@ -2220,7 +2217,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,

             if (ac->output_configured > OC_TRIAL_PCE)

                 av_log(avctx, AV_LOG_INFO,

                        "Evaluating a further program_config_element.\n");

-            err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE);

+            err = output_configure(ac, new_che_pos, 0, OC_TRIAL_PCE);

             if (!err)

                 ac->m4ac.chan_config = 0;

             break;

@@ -87,7 +87,7 @@ static const uint8_t aac_channel_layout_map[7][5][2] = {

     { { TYPE_CPE, 0 }, { TYPE_SCE, 0 }, { TYPE_SCE, 1 }, },

     { { TYPE_CPE, 0 }, { TYPE_SCE, 0 }, { TYPE_CPE, 1 }, },

     { { TYPE_CPE, 0 }, { TYPE_SCE, 0 }, { TYPE_LFE, 0 }, { TYPE_CPE, 1 }, },

-    { { TYPE_CPE, 0 }, { TYPE_SCE, 0 }, { TYPE_LFE, 0 }, { TYPE_CPE, 2 }, { TYPE_CPE, 1 }, },

+    { { TYPE_CPE, 1 }, { TYPE_SCE, 0 }, { TYPE_LFE, 0 }, { TYPE_CPE, 2 }, { TYPE_CPE, 0 }, },

 };

 static const uint64_t aac_channel_layout[8] = {

@@ -97,7 +97,7 @@ static const uint64_t aac_channel_layout[8] = {

     AV_CH_LAYOUT_4POINT0,

     AV_CH_LAYOUT_5POINT0_BACK,

     AV_CH_LAYOUT_5POINT1_BACK,

-    AV_CH_LAYOUT_7POINT1_WIDE,

+    AV_CH_LAYOUT_7POINT1_WIDE_BACK,

     0,

 };

@@ -1735,7 +1735,6 @@ typedef struct AVCodecContext {

 #define FF_DCT_FASTINT 1

 #define FF_DCT_INT     2

 #define FF_DCT_MMX     3

-#define FF_DCT_MLIB    4

 #define FF_DCT_ALTIVEC 5

 #define FF_DCT_FAAN    6

@@ -1786,7 +1785,6 @@ typedef struct AVCodecContext {

 #define FF_IDCT_SIMPLEMMX     3

 #define FF_IDCT_LIBMPEG2MMX   4

 #define FF_IDCT_PS2           5

-#define FF_IDCT_MLIB          6

 #define FF_IDCT_ARM           7

 #define FF_IDCT_ALTIVEC       8

 #define FF_IDCT_SH4           9

@@ -3960,7 +3958,10 @@ int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,

                              enum AVSampleFormat sample_fmt, const uint8_t *buf,

                              int buf_size, int align);

+#if FF_API_OLD_ENCODE_VIDEO

 /**

+ * @deprecated use avcodec_encode_video2() instead.

+ *

  * Encode a video frame from pict into buf.

  * The input picture should be

  * stored using a specific format, namely avctx.pix_fmt.

@@ -3972,8 +3973,44 @@ int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,

  * @return On error a negative value is returned, on success zero or the number

  * of bytes used from the output buffer.

  */

+attribute_deprecated

 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,

                          const AVFrame *pict);

+#endif

+

+/**

+ * Encode a frame of video.

+ *

+ * Takes input raw video data from frame and writes the next output packet, if

+ * available, to avpkt. The output packet does not necessarily contain data for

+ * the most recent frame, as encoders can delay and reorder input frames

+ * internally as needed.

+ *

+ * @param avctx     codec context

+ * @param avpkt     output AVPacket.

+ *                  The user can supply an output buffer by setting

+ *                  avpkt->data and avpkt->size prior to calling the

+ *                  function, but if the size of the user-provided data is not

+ *                  large enough, encoding will fail. All other AVPacket fields

+ *                  will be reset by the encoder using av_init_packet(). If

+ *                  avpkt->data is NULL, the encoder will allocate it.

+ *                  The encoder will set avpkt->size to the size of the

+ *                  output packet. The returned data (if any) belongs to the

+ *                  caller, he is responsible for freeing it.

+ * @param[in] frame AVFrame containing the raw video data to be encoded.

+ *                  May be NULL when flushing an encoder that has the

+ *                  CODEC_CAP_DELAY capability set.

+ * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the

+ *                            output packet is non-empty, and to 0 if it is

+ *                            empty. If the function returns an error, the

+ *                            packet can be assumed to be invalid, and the

+ *                            value of got_packet_ptr is undefined and should

+ *                            not be used.

+ * @return          0 on success, negative error code on failure

+ */

+int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,

+                          const AVFrame *frame, int *got_packet_ptr);

+

 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,

                             const AVSubtitle *sub);

@@ -3184,7 +3184,6 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)

     if (HAVE_MMX)        dsputil_init_mmx   (c, avctx);

     if (ARCH_ARM)        dsputil_init_arm   (c, avctx);

-    if (CONFIG_MLIB)     dsputil_init_mlib  (c, avctx);

     if (HAVE_VIS)        dsputil_init_vis   (c, avctx);

     if (ARCH_ALPHA)      dsputil_init_alpha (c, avctx);

     if (ARCH_PPC)        dsputil_init_ppc   (c, avctx);

@@ -644,7 +644,6 @@ static inline int get_penalty_factor(int lambda, int lambda2, int type){

 void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx);

 void dsputil_init_arm(DSPContext* c, AVCodecContext *avctx);

 void dsputil_init_bfin(DSPContext* c, AVCodecContext *avctx);

-void dsputil_init_mlib(DSPContext* c, AVCodecContext *avctx);

 void dsputil_init_mmi(DSPContext* c, AVCodecContext *avctx);

 void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx);

 void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx);

@@ -656,25 +655,9 @@ void ff_intrax8dsp_init(DSPContext* c, AVCodecContext *avctx);

 void ff_mlp_init(DSPContext* c, AVCodecContext *avctx);

 void ff_mlp_init_x86(DSPContext* c, AVCodecContext *avctx);

-

-#if ARCH_ARM

-

-

-#if HAVE_NEON

+#if (ARCH_ARM && HAVE_NEON) || ARCH_PPC || HAVE_MMI || HAVE_MMX

 #   define STRIDE_ALIGN 16

-#endif

-

-#elif ARCH_PPC

-

-#define STRIDE_ALIGN 16

-

-#elif HAVE_MMI

-

-#define STRIDE_ALIGN 16

-

-#endif

-

-#ifndef STRIDE_ALIGN

+#else

 #   define STRIDE_ALIGN 8

 #endif

@@ -361,15 +361,9 @@ int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height)

     AVPicture dummy_pict;

     if(av_image_check_size(width, height, 0, NULL))

         return -1;

-    switch (pix_fmt) {

-    case PIX_FMT_RGB8:

-    case PIX_FMT_BGR8:

-    case PIX_FMT_RGB4_BYTE:

-    case PIX_FMT_BGR4_BYTE:

-    case PIX_FMT_GRAY8:

+    if (av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_PSEUDOPAL)

         // do not include palette for these pseudo-paletted formats

         return width * height;

-    }

     return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);

 }

@@ -88,12 +88,23 @@ static void X264_log(void *p, int level, const char *fmt, va_list args)

 }

-static int encode_nals(AVCodecContext *ctx, uint8_t *buf, int size,

-                       x264_nal_t *nals, int nnal, int skip_sei)

+static int encode_nals(AVCodecContext *ctx, AVPacket *pkt,

+                       x264_nal_t *nals, int nnal)

 {

     X264Context *x4 = ctx->priv_data;

-    uint8_t *p = buf;

-    int i;

+    uint8_t *p;

+    int i, size = x4->sei_size, ret;

+

+    if (!nnal)

+        return 0;

+

+    for (i = 0; i < nnal; i++)

+        size += nals[i].i_payload;

+

+    if ((ret = ff_alloc_packet(pkt, size)) < 0)

+        return ret;

+

+    p = pkt->data;

     /* Write the SEI as part of the first frame. */

     if (x4->sei_size > 0 && nnal > 0) {

@@ -108,23 +119,11 @@ static int encode_nals(AVCodecContext *ctx, uint8_t *buf, int size,

     }

     for (i = 0; i < nnal; i++){

-        /* Don't put the SEI in extradata. */

-        if (skip_sei && nals[i].i_type == NAL_SEI) {

-            x4->sei_size = nals[i].i_payload;

-            x4->sei      = av_malloc(x4->sei_size);

-            memcpy(x4->sei, nals[i].p_payload, nals[i].i_payload);

-            continue;

-        }

-        if (nals[i].i_payload > (size - (p - buf))) {

-            // return only complete nals which fit in buf

-            av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n");

-            break;

-        }

         memcpy(p, nals[i].p_payload, nals[i].i_payload);

         p += nals[i].i_payload;

     }

-    return p - buf;

+    return 1;

 }

 static int avfmt2_num_planes(int avfmt)

@@ -146,15 +145,13 @@ static int avfmt2_num_planes(int avfmt)

     }

 }

-static int X264_frame(AVCodecContext *ctx, uint8_t *buf,

-                      int orig_bufsize, void *data)

+static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,

+                      int *got_packet)

 {

     X264Context *x4 = ctx->priv_data;

-    AVFrame *frame = data;

     x264_nal_t *nal;

-    int nnal, i;

+    int nnal, i, ret;

     x264_picture_t pic_out;

-    int bufsize;

     x264_picture_init( &x4->pic );

     x4->pic.img.i_csp   = x4->params.i_csp;

@@ -187,17 +184,16 @@ static int X264_frame(AVCodecContext *ctx, uint8_t *buf,

     }

     do {

-        bufsize = orig_bufsize;

         if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)

             return -1;

-        bufsize = encode_nals(ctx, buf, bufsize, nal, nnal, 0);

-        if (bufsize < 0)

+        ret = encode_nals(ctx, pkt, nal, nnal);

+        if (ret < 0)

             return -1;

-    } while (!bufsize && !frame && x264_encoder_delayed_frames(x4->enc));

+    } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));

-    /* FIXME: libx264 now provides DTS, but AVFrame doesn't have a field for it. */

-    x4->out_pic.pts = pic_out.i_pts;

+    pkt->pts = pic_out.i_pts;

+    pkt->dts = pic_out.i_dts;

     switch (pic_out.i_type) {

     case X264_TYPE_IDR:

@@ -213,11 +209,12 @@ static int X264_frame(AVCodecContext *ctx, uint8_t *buf,

         break;

     }

-    x4->out_pic.key_frame = pic_out.b_keyframe;

-    if (bufsize)

+    pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;

+    if (ret)

         x4->out_pic.quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;

-    return bufsize;

+    *got_packet = ret;

+    return 0;

 }

 static av_cold int X264_close(AVCodecContext *avctx)

@@ -485,16 +482,25 @@ static av_cold int X264_init(AVCodecContext *avctx)

     if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {

         x264_nal_t *nal;

+        uint8_t *p;

         int nnal, s, i;

         s = x264_encoder_headers(x4->enc, &nal, &nnal);

+        avctx->extradata = p = av_malloc(s);

-        for (i = 0; i < nnal; i++)

-            if (nal[i].i_type == NAL_SEI)

+        for (i = 0; i < nnal; i++) {

+            /* Don't put the SEI in extradata. */

+            if (nal[i].i_type == NAL_SEI) {

                 av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);

-

-        avctx->extradata      = av_malloc(s);

-        avctx->extradata_size = encode_nals(avctx, avctx->extradata, s, nal, nnal, 1);

+                x4->sei_size = nal[i].i_payload;

+                x4->sei      = av_malloc(x4->sei_size);

+                memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);

+                continue;

+            }

+            memcpy(p, nal[i].p_payload, nal[i].i_payload);

+            p += nal[i].i_payload;

+        }

+        avctx->extradata_size = p - avctx->extradata;

     }

     return 0;

@@ -634,7 +640,7 @@ AVCodec ff_libx264_encoder = {

     .id             = CODEC_ID_H264,

     .priv_data_size = sizeof(X264Context),

     .init           = X264_init,

-    .encode         = X264_frame,

+    .encode2        = X264_frame,

     .close          = X264_close,

     .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,

     .long_name      = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),

deleted file mode 100644

@@ -1,469 +0,0 @@

-/*

- * Sun mediaLib optimized DSP utils

- * Copyright (c) 2001 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 "libavcodec/dsputil.h"

-#include "libavcodec/mpegvideo.h"

-

-#include <mlib_types.h>

-#include <mlib_status.h>

-#include <mlib_sys.h>

-#include <mlib_algebra.h>

-#include <mlib_video.h>

-

-/* misc */

-

-static void get_pixels_mlib(DCTELEM *restrict block, const uint8_t *pixels, int line_size)

-{

-  int i;

-

-  for (i=0;i<8;i++) {

-    mlib_VectorConvert_S16_U8_Mod((mlib_s16 *)block, (mlib_u8 *)pixels, 8);

-

-    pixels += line_size;

-    block += 8;

-  }

-}

-

-static void diff_pixels_mlib(DCTELEM *restrict block, const uint8_t *s1, const uint8_t *s2, int line_size)

-{

-  int i;

-

-  for (i=0;i<8;i++) {

-    mlib_VectorSub_S16_U8_Mod((mlib_s16 *)block, (mlib_u8 *)s1, (mlib_u8 *)s2, 8);

-

-    s1 += line_size;

-    s2 += line_size;

-    block += 8;

-  }

-}

-

-static void add_pixels_clamped_mlib(const DCTELEM *block, uint8_t *pixels, int line_size)

-{

-    mlib_VideoAddBlock_U8_S16(pixels, (mlib_s16 *)block, line_size);

-}

-

-/* put block, width 16 pixel, height 8/16 */

-

-static void put_pixels16_mlib (uint8_t * dest, const uint8_t * ref,

-                               int stride, int height)

-{

-  switch (height) {

-    case 8:

-      mlib_VideoCopyRef_U8_U8_16x8(dest, (uint8_t *)ref, stride);

-    break;

-

-    case 16:

-      mlib_VideoCopyRef_U8_U8_16x16(dest, (uint8_t *)ref, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-static void put_pixels16_x2_mlib (uint8_t * dest, const uint8_t * ref,

-                                  int stride, int height)

-{

-  switch (height) {

-    case 8:

-      mlib_VideoInterpX_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 16:

-      mlib_VideoInterpX_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-static void put_pixels16_y2_mlib (uint8_t * dest, const uint8_t * ref,

-                                  int stride, int height)

-{

-  switch (height) {

-    case 8:

-      mlib_VideoInterpY_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 16:

-      mlib_VideoInterpY_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-static void put_pixels16_xy2_mlib(uint8_t * dest, const uint8_t * ref,

-                                  int stride, int height)

-{

-  switch (height) {

-    case 8:

-      mlib_VideoInterpXY_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 16:

-      mlib_VideoInterpXY_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-/* put block, width 8 pixel, height 4/8/16 */

-

-static void put_pixels8_mlib (uint8_t * dest, const uint8_t * ref,

-                               int stride, int height)

-{

-  switch (height) {

-    case 4:

-      mlib_VideoCopyRef_U8_U8_8x4(dest, (uint8_t *)ref, stride);

-    break;

-

-    case 8:

-      mlib_VideoCopyRef_U8_U8_8x8(dest, (uint8_t *)ref, stride);

-    break;

-

-    case 16:

-      mlib_VideoCopyRef_U8_U8_8x16(dest, (uint8_t *)ref, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-static void put_pixels8_x2_mlib (uint8_t * dest, const uint8_t * ref,

-                                  int stride, int height)

-{

-  switch (height) {

-    case 4:

-      mlib_VideoInterpX_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 8:

-      mlib_VideoInterpX_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 16:

-      mlib_VideoInterpX_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-static void put_pixels8_y2_mlib (uint8_t * dest, const uint8_t * ref,

-                                  int stride, int height)

-{

-  switch (height) {

-    case 4:

-      mlib_VideoInterpY_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 8:

-      mlib_VideoInterpY_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 16:

-      mlib_VideoInterpY_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-static void put_pixels8_xy2_mlib(uint8_t * dest, const uint8_t * ref,

-                                  int stride, int height)

-{

-  switch (height) {

-    case 4:

-      mlib_VideoInterpXY_U8_U8_8x4(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 8:

-      mlib_VideoInterpXY_U8_U8_8x8(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 16:

-      mlib_VideoInterpXY_U8_U8_8x16(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-/* average block, width 16 pixel, height 8/16 */

-

-static void avg_pixels16_mlib (uint8_t * dest, const uint8_t * ref,

-                               int stride, int height)

-{

-  switch (height) {

-    case 8:

-      mlib_VideoCopyRefAve_U8_U8_16x8(dest, (uint8_t *)ref, stride);

-    break;

-

-    case 16:

-      mlib_VideoCopyRefAve_U8_U8_16x16(dest, (uint8_t *)ref, stride);

-    break;

-

-    default:

-      assert(0);

-  }

-}

-

-static void avg_pixels16_x2_mlib (uint8_t * dest, const uint8_t * ref,

-                                  int stride, int height)

-{

-  switch (height) {

-    case 8:

-      mlib_VideoInterpAveX_U8_U8_16x8(dest, (uint8_t *)ref, stride, stride);

-    break;

-

-    case 16:

-      mlib_VideoInterpAveX_U8_U8_16x16(dest, (uint8_t *)ref, stride, stride);