Merge remote-tracking branch 'qatar/master'

* qatar/master:
  x86: dsputil: Only compile motion_est code when encoders are enabled
  mem: fix typo in check for __ICC
  fate: mp3: drop redundant CMP setting
  rtp: Depacketization of JPEG (RFC 2435)
  Rename ff_put_string to avpriv_put_string
  mjpeg: Rename some symbols to avpriv_* instead of ff_*
  yadif: cosmetics

Conflicts:
	Changelog
	libavcodec/mjpegenc.c
	libavcodec/x86/Makefile
	libavfilter/vf_yadif.c
	libavformat/version.h
	libavutil/mem.h
Merged-by: Michael Niedermayer <michaelni@gmx.at>

Changelog

@@ -59,6 +59,7 @@ version next:
 - smartblur filter ported from MPlayer
 - CPiA decoder
 - decimate filter ported from MPlayer
+- RTP depacketization of JPEG
 
 
 version 0.11:

libavcodec/Makefile

@@ -628,6 +628,7 @@ OBJS-$(CONFIG_OGG_DEMUXER)             += xiph.o flac.o flacdata.o     \
 OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flac.o flacdata.o \
                                           vorbis_data.o
 OBJS-$(CONFIG_RTP_MUXER)               += mpeg4audio.o xiph.o
+OBJS-$(CONFIG_RTPDEC)                  += mjpeg.o
 OBJS-$(CONFIG_SPDIF_DEMUXER)           += aacadtsdec.o mpeg4audio.o
 OBJS-$(CONFIG_SPDIF_MUXER)             += dca.o
 OBJS-$(CONFIG_WEBM_MUXER)              += mpeg4audio.o mpegaudiodata.o  \

libavcodec/bitstream.c

@@ -47,7 +47,7 @@ void avpriv_align_put_bits(PutBitContext *s)
     put_bits(s,s->bit_left & 7,0);
 }
 
-void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
+void avpriv_put_string(PutBitContext *pb, const char *string, int terminate_string)
 {
     while(*string){
         put_bits(pb, 8, *string);

libavcodec/mjpeg.c

@@ -62,17 +62,17 @@ const unsigned char std_chrominance_quant_tbl[64] = {
 
 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
 /* IMPORTANT: these are only valid for 8-bit data precision! */
-const uint8_t ff_mjpeg_bits_dc_luminance[17] =
+const uint8_t avpriv_mjpeg_bits_dc_luminance[17] =
 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
-const uint8_t ff_mjpeg_val_dc[12] =
+const uint8_t avpriv_mjpeg_val_dc[12] =
 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 
-const uint8_t ff_mjpeg_bits_dc_chrominance[17] =
+const uint8_t avpriv_mjpeg_bits_dc_chrominance[17] =
 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 
-const uint8_t ff_mjpeg_bits_ac_luminance[17] =
+const uint8_t avpriv_mjpeg_bits_ac_luminance[17] =
 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
-const uint8_t ff_mjpeg_val_ac_luminance[] =
+const uint8_t avpriv_mjpeg_val_ac_luminance[] =
 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
@@ -96,10 +96,10 @@ const uint8_t ff_mjpeg_val_ac_luminance[] =
   0xf9, 0xfa
 };
 
-const uint8_t ff_mjpeg_bits_ac_chrominance[17] =
+const uint8_t avpriv_mjpeg_bits_ac_chrominance[17] =
 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 
-const uint8_t ff_mjpeg_val_ac_chrominance[] =
+const uint8_t avpriv_mjpeg_val_ac_chrominance[] =
 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,

libavcodec/mjpeg.h

@@ -138,16 +138,16 @@ static inline void put_marker(PutBitContext *p, int code)
         case 7: ret= (left + top)>>1; break;\
     }
 
-extern const uint8_t ff_mjpeg_bits_dc_luminance[];
-extern const uint8_t ff_mjpeg_val_dc[];
+extern const uint8_t avpriv_mjpeg_bits_dc_luminance[];
+extern const uint8_t avpriv_mjpeg_val_dc[];
 
-extern const uint8_t ff_mjpeg_bits_dc_chrominance[];
+extern const uint8_t avpriv_mjpeg_bits_dc_chrominance[];
 
-extern const uint8_t ff_mjpeg_bits_ac_luminance[];
-extern const uint8_t ff_mjpeg_val_ac_luminance[];
+extern const uint8_t avpriv_mjpeg_bits_ac_luminance[];
+extern const uint8_t avpriv_mjpeg_val_ac_luminance[];
 
-extern const uint8_t ff_mjpeg_bits_ac_chrominance[];
-extern const uint8_t ff_mjpeg_val_ac_chrominance[];
+extern const uint8_t avpriv_mjpeg_bits_ac_chrominance[];
+extern const uint8_t avpriv_mjpeg_val_ac_chrominance[];
 
 void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
                                   const uint8_t *bits_table,

libavcodec/mjpeg2jpeg_bsf.c

@@ -59,15 +59,15 @@ static uint8_t *append(uint8_t *buf, const uint8_t *src, int size)
 static uint8_t *append_dht_segment(uint8_t *buf)
 {
     buf = append(buf, dht_segment_head, sizeof(dht_segment_head));
-    buf = append(buf, ff_mjpeg_bits_dc_luminance + 1, 16);
+    buf = append(buf, avpriv_mjpeg_bits_dc_luminance + 1, 16);
     buf = append(buf, dht_segment_frag, sizeof(dht_segment_frag));
-    buf = append(buf, ff_mjpeg_val_dc, 12);
+    buf = append(buf, avpriv_mjpeg_val_dc, 12);
     *(buf++) = 0x10;
-    buf = append(buf, ff_mjpeg_bits_ac_luminance + 1, 16);
-    buf = append(buf, ff_mjpeg_val_ac_luminance, 162);
+    buf = append(buf, avpriv_mjpeg_bits_ac_luminance + 1, 16);
+    buf = append(buf, avpriv_mjpeg_val_ac_luminance, 162);
     *(buf++) = 0x11;
-    buf = append(buf, ff_mjpeg_bits_ac_chrominance + 1, 16);
-    buf = append(buf, ff_mjpeg_val_ac_chrominance, 162);
+    buf = append(buf, avpriv_mjpeg_bits_ac_chrominance + 1, 16);
+    buf = append(buf, avpriv_mjpeg_val_ac_chrominance, 162);
     return buf;
 }
 

libavcodec/mjpegdec.c

@@ -65,18 +65,18 @@ static int build_vlc(VLC *vlc, const uint8_t *bits_table,
 
 static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
 {
-    build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance,
-              ff_mjpeg_val_dc, 12, 0, 0);
-    build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance,
-              ff_mjpeg_val_dc, 12, 0, 0);
-    build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance,
-              ff_mjpeg_val_ac_luminance, 251, 0, 1);
-    build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance,
-              ff_mjpeg_val_ac_chrominance, 251, 0, 1);
-    build_vlc(&s->vlcs[2][0], ff_mjpeg_bits_ac_luminance,
-              ff_mjpeg_val_ac_luminance, 251, 0, 0);
-    build_vlc(&s->vlcs[2][1], ff_mjpeg_bits_ac_chrominance,
-              ff_mjpeg_val_ac_chrominance, 251, 0, 0);
+    build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
+              avpriv_mjpeg_val_dc, 12, 0, 0);
+    build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
+              avpriv_mjpeg_val_dc, 12, 0, 0);
+    build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
+              avpriv_mjpeg_val_ac_luminance, 251, 0, 1);
+    build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
+              avpriv_mjpeg_val_ac_chrominance, 251, 0, 1);
+    build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
+              avpriv_mjpeg_val_ac_luminance, 251, 0, 0);
+    build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
+              avpriv_mjpeg_val_ac_chrominance, 251, 0, 0);
 }
 
 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)

libavcodec/mjpegenc.c

@@ -60,20 +60,20 @@ av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
     /* build all the huffman tables */
     ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
                                  m->huff_code_dc_luminance,
-                                 ff_mjpeg_bits_dc_luminance,
-                                 ff_mjpeg_val_dc);
+                                 avpriv_mjpeg_bits_dc_luminance,
+                                 avpriv_mjpeg_val_dc);
     ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
                                  m->huff_code_dc_chrominance,
-                                 ff_mjpeg_bits_dc_chrominance,
-                                 ff_mjpeg_val_dc);
+                                 avpriv_mjpeg_bits_dc_chrominance,
+                                 avpriv_mjpeg_val_dc);
     ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
                                  m->huff_code_ac_luminance,
-                                 ff_mjpeg_bits_ac_luminance,
-                                 ff_mjpeg_val_ac_luminance);
+                                 avpriv_mjpeg_bits_ac_luminance,
+                                 avpriv_mjpeg_val_ac_luminance);
     ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
                                  m->huff_code_ac_chrominance,
-                                 ff_mjpeg_bits_ac_chrominance,
-                                 ff_mjpeg_val_ac_chrominance);
+                                 avpriv_mjpeg_bits_ac_chrominance,
+                                 avpriv_mjpeg_val_ac_chrominance);
 
     s->mjpeg_ctx = m;
     return 0;
@@ -146,15 +146,15 @@ static void jpeg_table_header(MpegEncContext *s)
     ptr = put_bits_ptr(p);
     put_bits(p, 16, 0); /* patched later */
     size = 2;
-    size += put_huffman_table(s, 0, 0, ff_mjpeg_bits_dc_luminance,
-                              ff_mjpeg_val_dc);
-    size += put_huffman_table(s, 0, 1, ff_mjpeg_bits_dc_chrominance,
-                              ff_mjpeg_val_dc);
-
-    size += put_huffman_table(s, 1, 0, ff_mjpeg_bits_ac_luminance,
-                              ff_mjpeg_val_ac_luminance);
-    size += put_huffman_table(s, 1, 1, ff_mjpeg_bits_ac_chrominance,
-                              ff_mjpeg_val_ac_chrominance);
+    size += put_huffman_table(s, 0, 0, avpriv_mjpeg_bits_dc_luminance,
+                              avpriv_mjpeg_val_dc);
+    size += put_huffman_table(s, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
+                              avpriv_mjpeg_val_dc);
+
+    size += put_huffman_table(s, 1, 0, avpriv_mjpeg_bits_ac_luminance,
+                              avpriv_mjpeg_val_ac_luminance);
+    size += put_huffman_table(s, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
+                              avpriv_mjpeg_val_ac_chrominance);
     AV_WB16(ptr, size);
 }
 
@@ -169,7 +169,7 @@ static void jpeg_put_comments(MpegEncContext *s)
     /* JFIF header */
     put_marker(p, APP0);
     put_bits(p, 16, 16);
-    ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
+    avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
     put_bits(p, 16, 0x0102); /* v 1.02 */
     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
     put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
@@ -184,7 +184,7 @@ static void jpeg_put_comments(MpegEncContext *s)
         flush_put_bits(p);
         ptr = put_bits_ptr(p);
         put_bits(p, 16, 0); /* patched later */
-        ff_put_string(p, LIBAVCODEC_IDENT, 1);
+        avpriv_put_string(p, LIBAVCODEC_IDENT, 1);
         size = strlen(LIBAVCODEC_IDENT)+3;
         AV_WB16(ptr, size);
     }
@@ -196,7 +196,7 @@ static void jpeg_put_comments(MpegEncContext *s)
         flush_put_bits(p);
         ptr = put_bits_ptr(p);
         put_bits(p, 16, 0); /* patched later */
-        ff_put_string(p, "CS=ITU601", 1);
+        avpriv_put_string(p, "CS=ITU601", 1);
         size = strlen("CS=ITU601")+3;
         AV_WB16(ptr, size);
     }

libavcodec/mpeg4videoenc.c

@@ -1035,7 +1035,7 @@ static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_n
     if(!(s->flags & CODEC_FLAG_BITEXACT)){
         put_bits(&s->pb, 16, 0);
         put_bits(&s->pb, 16, 0x1B2);    /* user_data */
-        ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
+        avpriv_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
     }
 }
 

libavcodec/put_bits.h

@@ -99,7 +99,7 @@ static inline void flush_put_bits(PutBitContext *s)
 
 #ifdef BITSTREAM_WRITER_LE
 #define avpriv_align_put_bits align_put_bits_unsupported_here
-#define ff_put_string ff_put_string_unsupported_here
+#define avpriv_put_string ff_put_string_unsupported_here
 #define avpriv_copy_bits avpriv_copy_bits_unsupported_here
 #else
 /**
@@ -112,7 +112,7 @@ void avpriv_align_put_bits(PutBitContext *s);
  *
  * @param terminate_string 0-terminates the written string if value is 1
  */
-void ff_put_string(PutBitContext *pb, const char *string, int terminate_string);
+void avpriv_put_string(PutBitContext *pb, const char *string, int terminate_string);
 
 /**
  * Copy the content of src to the bitstream.

libavcodec/x86/Makefile

@@ -11,7 +11,6 @@ MMX-OBJS                               += x86/dsputil_mmx.o             \
                                           x86/fmtconvert_init.o         \
                                           x86/idct_mmx_xvid.o           \
                                           x86/idct_sse2_xvid.o          \
-                                          x86/motion_est.o              \
                                           x86/simple_idct.o             \
 
 MMX-OBJS-$(CONFIG_AAC_DECODER)         += x86/sbrdsp_init.o
@@ -19,7 +18,8 @@ MMX-OBJS-$(CONFIG_AC3DSP)              += x86/ac3dsp_init.o
 MMX-OBJS-$(CONFIG_CAVS_DECODER)        += x86/cavsdsp.o
 MMX-OBJS-$(CONFIG_DWT)                 += x86/snowdsp.o \
                                           x86/dwt.o
-MMX-OBJS-$(CONFIG_ENCODERS)            += x86/dsputilenc_mmx.o
+MMX-OBJS-$(CONFIG_ENCODERS)            += x86/dsputilenc_mmx.o          \
+                                          x86/motion_est.o
 MMX-OBJS-$(CONFIG_FFT)                 += x86/fft_init.o
 MMX-OBJS-$(CONFIG_GPL)                 += x86/idct_mmx.o
 MMX-OBJS-$(CONFIG_H264DSP)             += x86/h264dsp_init.o

libavfilter/vf_yadif.c

@@ -30,6 +30,8 @@
 #undef NDEBUG
 #include <assert.h>
 
+#define PERM_RWP AV_PERM_WRITE | AV_PERM_PRESERVE | AV_PERM_REUSE
+
 #define CHECK(j)\
     {   int score = FFABS(cur[mrefs-1+(j)] - cur[prefs-1-(j)])\
                   + FFABS(cur[mrefs  +(j)] - cur[prefs  -(j)])\
@@ -46,19 +48,19 @@
         int temporal_diff0 = FFABS(prev2[0] - next2[0]); \
         int temporal_diff1 =(FFABS(prev[mrefs] - c) + FFABS(prev[prefs] - e) )>>1; \
         int temporal_diff2 =(FFABS(next[mrefs] - c) + FFABS(next[prefs] - e) )>>1; \
-        int diff = FFMAX3(temporal_diff0>>1, temporal_diff1, temporal_diff2); \
-        int spatial_pred = (c+e)>>1; \
-        int spatial_score = FFABS(cur[mrefs-1] - cur[prefs-1]) + FFABS(c-e) \
-                          + FFABS(cur[mrefs+1] - cur[prefs+1]) - 1; \
+        int diff = FFMAX3(temporal_diff0 >> 1, temporal_diff1, temporal_diff2); \
+        int spatial_pred = (c+e) >> 1; \
+        int spatial_score = FFABS(cur[mrefs - 1] - cur[prefs - 1]) + FFABS(c-e) \
+                          + FFABS(cur[mrefs + 1] - cur[prefs + 1]) - 1; \
  \
         CHECK(-1) CHECK(-2) }} }} \
         CHECK( 1) CHECK( 2) }} }} \
  \
         if (mode < 2) { \
-            int b = (prev2[2*mrefs] + next2[2*mrefs])>>1; \
-            int f = (prev2[2*prefs] + next2[2*prefs])>>1; \
-            int max = FFMAX3(d-e, d-c, FFMIN(b-c, f-e)); \
-            int min = FFMIN3(d-e, d-c, FFMAX(b-c, f-e)); \
+            int b = (prev2[2 * mrefs] + next2[2 * mrefs])>>1; \
+            int f = (prev2[2 * prefs] + next2[2 * prefs])>>1; \
+            int max = FFMAX3(d - e, d - c, FFMIN(b - c, f - e)); \
+            int min = FFMIN3(d - e, d - c, FFMAX(b - c, f - e)); \
  \
             diff = FFMAX3(diff, min, -max); \
         } \
@@ -91,7 +93,8 @@ static void filter_line_c(uint8_t *dst,
 
 static void filter_line_c_16bit(uint16_t *dst,
                                 uint16_t *prev, uint16_t *cur, uint16_t *next,
-                                int w, int prefs, int mrefs, int parity, int mode)
+                                int w, int prefs, int mrefs, int parity,
+                                int mode)
 {
     int x;
     uint16_t *prev2 = parity ? prev : cur ;
@@ -129,11 +132,11 @@ static void filter(AVFilterContext *ctx, AVFilterBufferRef *dstpic,
 
         for (y = 0; y < h; y++) {
             if ((y ^ parity) & 1) {
-                uint8_t *prev = &yadif->prev->data[i][y*refs];
-                uint8_t *cur  = &yadif->cur ->data[i][y*refs];
-                uint8_t *next = &yadif->next->data[i][y*refs];
-                uint8_t *dst  = &dstpic->data[i][y*dstpic->linesize[i]];
-                int     mode  = y==1 || y+2==h ? 2 : yadif->mode;
+                uint8_t *prev = &yadif->prev->data[i][y * refs];
+                uint8_t *cur  = &yadif->cur ->data[i][y * refs];
+                uint8_t *next = &yadif->next->data[i][y * refs];
+                uint8_t *dst  = &dstpic->data[i][y * dstpic->linesize[i]];
+                int     mode  = y == 1 || y + 2 == h ? 2 : yadif->mode;
                 int     prefs = y+1<h ? refs : -refs;
                 int     mrefs =     y ?-refs :  refs;
 
@@ -151,10 +154,12 @@ static void filter(AVFilterContext *ctx, AVFilterBufferRef *dstpic,
                     cur = tmp;
                 }
 
-                yadif->filter_line(dst, prev, cur, next, w, prefs, mrefs, parity ^ tff, mode);
+                yadif->filter_line(dst, prev, cur, next, w,
+                                   prefs, mrefs,
+                                   parity ^ tff, mode);
             } else {
-                memcpy(&dstpic->data[i][y*dstpic->linesize[i]],
-                       &yadif->cur->data[i][y*refs], w*df);
+                memcpy(&dstpic->data[i][y * dstpic->linesize[i]],
+                       &yadif->cur->data[i][y * refs], w * df);
             }
         }
     }
@@ -165,19 +170,18 @@ static void filter(AVFilterContext *ctx, AVFilterBufferRef *dstpic,
 static int return_frame(AVFilterContext *ctx, int is_second)
 {
     YADIFContext *yadif = ctx->priv;
-    AVFilterLink *link= ctx->outputs[0];
+    AVFilterLink *link  = ctx->outputs[0];
     int tff, ret;
 
     if (yadif->parity == -1) {
         tff = yadif->cur->video->interlaced ?
               yadif->cur->video->top_field_first : 1;
     } else {
-        tff = yadif->parity^1;
+        tff = yadif->parity ^ 1;
     }
 
     if (is_second) {
-        yadif->out = ff_get_video_buffer(link, AV_PERM_WRITE | AV_PERM_PRESERVE |
-                                         AV_PERM_REUSE, link->w, link->h);
+        yadif->out = ff_get_video_buffer(link, PERM_RWP, link->w, link->h);
         if (!yadif->out)
             return AVERROR(ENOMEM);
 
@@ -253,15 +257,17 @@ static int start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
         !(yadif->prev = avfilter_ref_buffer(yadif->cur, ~AV_PERM_WRITE)))
         return AVERROR(ENOMEM);
 
-    yadif->out = ff_get_video_buffer(ctx->outputs[0], AV_PERM_WRITE | AV_PERM_PRESERVE |
-                                     AV_PERM_REUSE, link->w, link->h);
+    yadif->out = ff_get_video_buffer(ctx->outputs[0], PERM_RWP,
+                                     link->w, link->h);
     if (!yadif->out)
         return AVERROR(ENOMEM);
 
     avfilter_copy_buffer_ref_props(yadif->out, yadif->cur);
     yadif->out->video->interlaced = 0;
+
     if (yadif->out->pts != AV_NOPTS_VALUE)
         yadif->out->pts *= 2;
+
     return ff_start_frame(ctx->outputs[0], yadif->out);
 }
 
@@ -304,6 +310,7 @@ static int request_frame(AVFilterLink *link)
 
         if (ret == AVERROR_EOF && yadif->cur) {
             AVFilterBufferRef *next = avfilter_ref_buffer(yadif->next, ~AV_PERM_WRITE);
+
             if (!next)
                 return AVERROR(ENOMEM);
 
@@ -332,7 +339,8 @@ static int poll_frame(AVFilterLink *link)
     if (val <= 0)
         return val;
 
-    if (val >= 1 && !yadif->next) { //FIXME change API to not requre this red tape
+    //FIXME change API to not requre this red tape
+    if (val >= 1 && !yadif->next) {
         if ((ret = ff_request_frame(link->src->inputs[0])) < 0)
             return ret;
         val = ff_poll_frame(link->src->inputs[0]);
@@ -398,14 +406,17 @@ static av_cold int init(AVFilterContext *ctx, const char *args)
     yadif->auto_enable = 0;
     yadif->csp = NULL;
 
-    if (args) sscanf(args, "%d:%d:%d", &yadif->mode, &yadif->parity, &yadif->auto_enable);
+    if (args)
+        sscanf(args, "%d:%d:%d",
+               &yadif->mode, &yadif->parity, &yadif->auto_enable);
 
     yadif->filter_line = filter_line_c;
 
     if (HAVE_MMX)
         ff_yadif_init_x86(yadif);
 
-    av_log(ctx, AV_LOG_VERBOSE, "mode:%d parity:%d auto_enable:%d\n", yadif->mode, yadif->parity, yadif->auto_enable);
+    av_log(ctx, AV_LOG_VERBOSE, "mode:%d parity:%d auto_enable:%d\n",
+           yadif->mode, yadif->parity, yadif->auto_enable);
 
     return 0;
 }

libavformat/Makefile

@@ -293,6 +293,7 @@ OBJS-$(CONFIG_RTPDEC)                    += rdt.o         \
                                             rtpdec_h263_rfc2190.o \
                                             rtpdec_h264.o \
                                             rtpdec_ilbc.o \
+                                            rtpdec_jpeg.o \
                                             rtpdec_latm.o \
                                             rtpdec_mpeg4.o \
                                             rtpdec_qcelp.o \

libavformat/rtpdec.c

@@ -69,6 +69,7 @@ void av_register_rtp_dynamic_payload_handlers(void)
     ff_register_dynamic_payload_handler(&ff_h263_rfc2190_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_ilbc_dynamic_handler);
+    ff_register_dynamic_payload_handler(&ff_jpeg_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_qdm2_dynamic_handler);

libavformat/rtpdec_formats.h

@@ -46,6 +46,7 @@ extern RTPDynamicProtocolHandler ff_h263_2000_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_h263_rfc2190_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_h264_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_ilbc_dynamic_handler;
+extern RTPDynamicProtocolHandler ff_jpeg_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_mp4a_latm_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler;

libavformat/version.h

@@ -30,8 +30,8 @@
 #include "libavutil/avutil.h"
 
 #define LIBAVFORMAT_VERSION_MAJOR 54
-#define LIBAVFORMAT_VERSION_MINOR 25
-#define LIBAVFORMAT_VERSION_MICRO 105
+#define LIBAVFORMAT_VERSION_MINOR 26
+#define LIBAVFORMAT_VERSION_MICRO 100
 
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                LIBAVFORMAT_VERSION_MINOR, \

tests/fate/mp3.mak

 FATE_MP3 += fate-mp3-float-conf-compl
 fate-mp3-float-conf-compl: CMD = pcm -acodec mp3float -i $(SAMPLES)/mp3-conformance/compl.bit
-fate-mp3-float-conf-compl: CMP = stddev
 fate-mp3-float-conf-compl: REF = $(SAMPLES)/mp3-conformance/compl.pcm
 
 FATE_MP3 += fate-mp3-float-conf-he_32khz
 fate-mp3-float-conf-he_32khz: CMD = pcm -acodec mp3float -i $(SAMPLES)/mp3-conformance/he_32khz.bit -fs 343296
-fate-mp3-float-conf-he_32khz: CMP = stddev
 fate-mp3-float-conf-he_32khz: REF = $(SAMPLES)/mp3-conformance/he_32khz.pcm
 
 FATE_MP3 += fate-mp3-float-conf-he_44khz
 fate-mp3-float-conf-he_44khz: CMD = pcm -acodec mp3float -i $(SAMPLES)/mp3-conformance/he_44khz.bit -fs 942336
-fate-mp3-float-conf-he_44khz: CMP = stddev
 fate-mp3-float-conf-he_44khz: REF = $(SAMPLES)/mp3-conformance/he_44khz.pcm
 
 FATE_MP3 += fate-mp3-float-conf-he_48khz
 fate-mp3-float-conf-he_48khz: CMD = pcm -acodec mp3float -i $(SAMPLES)/mp3-conformance/he_48khz.bit -fs 343296
-fate-mp3-float-conf-he_48khz: CMP = stddev
 fate-mp3-float-conf-he_48khz: REF = $(SAMPLES)/mp3-conformance/he_48khz.pcm
 
 FATE_MP3 += fate-mp3-float-conf-hecommon
 fate-mp3-float-conf-hecommon: CMD = pcm -acodec mp3float -i $(SAMPLES)/mp3-conformance/hecommon.bit -fs 133632
-fate-mp3-float-conf-hecommon: CMP = stddev
 fate-mp3-float-conf-hecommon: REF = $(SAMPLES)/mp3-conformance/hecommon.pcm
 
 FATE_MP3 += fate-mp3-float-conf-si
 fate-mp3-float-conf-si: CMD = pcm -acodec mp3float -i $(SAMPLES)/mp3-conformance/si.bit -fs 269568
-fate-mp3-float-conf-si: CMP = stddev
 fate-mp3-float-conf-si: REF = $(SAMPLES)/mp3-conformance/si.pcm
 
 FATE_MP3 += fate-mp3-float-conf-si_block
 fate-mp3-float-conf-si_block: CMD = pcm -acodec mp3float -i $(SAMPLES)/mp3-conformance/si_block.bit -fs 145152
-fate-mp3-float-conf-si_block: CMP = stddev
 fate-mp3-float-conf-si_block: REF = $(SAMPLES)/mp3-conformance/si_block.pcm
 
 FATE_MP3 += fate-mp3-float-extra_overread
 fate-mp3-float-extra_overread: CMD = pcm -c:a mp3float -i $(SAMPLES)/mpegaudio/extra_overread.mp3
-fate-mp3-float-extra_overread: CMP = stddev
 fate-mp3-float-extra_overread: REF = $(SAMPLES)/mpegaudio/extra_overread.pcm
 
 FATE_SAMPLES_AVCONV += $(FATE_MP3)