Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 10 Sep 2012 12:05:42 +0000 (14:05 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 10 Sep 2012 12:06:20 +0000 (14:06 +0200)
* 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>
17 files changed:
1  2 
Changelog
libavcodec/Makefile
libavcodec/bitstream.c
libavcodec/mjpeg.c
libavcodec/mjpeg.h
libavcodec/mjpeg2jpeg_bsf.c
libavcodec/mjpegdec.c
libavcodec/mjpegenc.c
libavcodec/mpeg4videoenc.c
libavcodec/put_bits.h
libavcodec/x86/Makefile
libavfilter/vf_yadif.c
libavformat/Makefile
libavformat/rtpdec.c
libavformat/rtpdec_formats.h
libavformat/rtpdec_jpeg.c
libavformat/version.h

diff --cc Changelog
+++ b/Changelog
@@@ -21,136 -37,39 +21,137 @@@ version next
  - Microsoft Expression Encoder Screen decoder
  - RTMPS protocol support
  - RTMPTS protocol support
 -- JPEG 2000 encoding support through OpenJPEG
 -- G.723.1 demuxer and decoder
  - RTMPE protocol support
  - RTMPTE protocol support
 +- showwaves and showspectrum filter
 +- LucasArts SMUSH playback support
 +- SAMI, RealText and SubViewer demuxers and decoders
 +- Heart Of Darkness PAF playback support
 +- iec61883 device
 +- asettb filter
 +- new option: -progress
 +- 3GPP Timed Text encoder/decoder
 +- GeoTIFF decoder support
 +- ffmpeg -(no)stdin option
 +- Opus decoder using libopus
 +- caca output device using libcaca
 +- alphaextract and alphamerge filters
 +- concat filter
 +- flite filter
  - Canopus Lossless Codec decoder
 -- avconv -shortest option is now per-output file,
 +- bitmap subtitles in filters (experimental and temporary)
 +- MP2 encoding via TwoLAME
 +- bmp parser
 +- smptebars source
 +- asetpts filter
 +- hue filter
 +- ICO muxer
 +- SubRip encoder and decoder without embedded timing
 +- edge detection filter
 +- framestep filter
 +- ffmpeg -shortest option is now per-output file
    -pass and -passlogfile are now per-output stream
 +- volume measurement filter
  - Ut Video encoder
  - Microsoft Screen 2 decoder
 +- Matroska demuxer now identifies SRT subtitles as AV_CODEC_ID_SUBRIP
 +  instead of AV_CODEC_ID_TEXT
 +- smartblur filter ported from MPlayer
 +- CPiA decoder
 +- decimate filter ported from MPlayer
+ - RTP depacketization of JPEG
  
  
 -version 0.8:
 +version 0.11:
  
 -- GSM audio parser
 -- SMJPEG muxer
 +- Fixes: CVE-2012-2772, CVE-2012-2774, CVE-2012-2775, CVE-2012-2776, CVE-2012-2777,
 +         CVE-2012-2779, CVE-2012-2782, CVE-2012-2783, CVE-2012-2784, CVE-2012-2785,
 +         CVE-2012-2786, CVE-2012-2787, CVE-2012-2788, CVE-2012-2789, CVE-2012-2790,
 +         CVE-2012-2791, CVE-2012-2792, CVE-2012-2793, CVE-2012-2794, CVE-2012-2795,
 +         CVE-2012-2796, CVE-2012-2797, CVE-2012-2798, CVE-2012-2799, CVE-2012-2800,
 +         CVE-2012-2801, CVE-2012-2802, CVE-2012-2803, CVE-2012-2804,
 +- v408 Quicktime and Microsoft AYUV Uncompressed 4:4:4:4 encoder and decoder
 +- setfield filter
 +- CDXL demuxer and decoder
 +- Apple ProRes encoder
 +- ffprobe -count_packets and -count_frames options
 +- Sun Rasterfile Encoder
 +- ID3v2 attached pictures reading and writing
 +- WMA Lossless decoder
 +- bluray protocol
 +- blackdetect filter
 +- libutvideo encoder wrapper (--enable-libutvideo)
 +- swapuv filter
 +- bbox filter
 +- XBM encoder and decoder
 +- RealAudio Lossless decoder
 +- ZeroCodec decoder
 +- tile video filter
 +- Metal Gear Solid: The Twin Snakes demuxer
 +- OpenEXR image decoder
 +- removelogo filter
 +- drop support for ffmpeg without libavfilter
 +- drawtext video filter: fontconfig support
 +- ffmpeg -benchmark_all option
 +- super2xsai filter ported from libmpcodecs
 +- add libavresample audio conversion library for compatibility
 +- MicroDVD decoder
 +- Avid Meridien (AVUI) encoder and decoder
 +- accept + prefix to -pix_fmt option to disable automatic conversions.
 +- complete audio filtering in libavfilter and ffmpeg
 +- add fps filter
 +- vorbis parser
 +- png parser
 +- audio mix filter
  
  
 -version 0.8_beta2:
 +version 0.10:
  
 +- Fixes: CVE-2011-3929, CVE-2011-3934, CVE-2011-3935, CVE-2011-3936,
 +         CVE-2011-3937, CVE-2011-3940, CVE-2011-3941, CVE-2011-3944,
 +         CVE-2011-3945, CVE-2011-3946, CVE-2011-3947, CVE-2011-3949,
 +         CVE-2011-3950, CVE-2011-3951, CVE-2011-3952
 +- v410 Quicktime Uncompressed 4:4:4 10-bit encoder and decoder
 +- SBaGen (SBG) binaural beats script demuxer
 +- OpenMG Audio muxer
 +- Timecode extraction in DV and MOV
 +- thumbnail video filter
 +- XML output in ffprobe
 +- asplit audio filter
 +- tinterlace video filter
 +- astreamsync audio filter
 +- amerge audio filter
 +- ISMV (Smooth Streaming) muxer
 +- GSM audio parser
 +- SMJPEG muxer
 +- XWD encoder and decoder
  - Automatic thread count based on detection number of (available) CPU cores
 -- Deprecate libpostproc. If desired, the switch --enable-postproc will
 -  enable it but it may be removed in a later Libav release.
 +- y41p Brooktree Uncompressed 4:1:1 12-bit encoder and decoder
 +- ffprobe -show_error option
 +- Avid 1:1 10-bit RGB Packer codec
 +- v308 Quicktime Uncompressed 4:4:4 encoder and decoder
 +- yuv4 libquicktime packed 4:2:0 encoder and decoder
 +- ffprobe -show_frames option
 +- silencedetect audio filter
 +- ffprobe -show_program_version, -show_library_versions, -show_versions options
  - rv34: frame-level multi-threading
  - optimized iMDCT transform on x86 using SSE for for mpegaudiodec
 +- Improved PGS subtitle decoder
 +- dumpgraph option to lavfi device
 +- r210 and r10k encoders
 +- ffwavesynth decoder
 +- aviocat tool
 +- ffeval tool
  
  
 -version 0.8_beta1:
 +version 0.9:
  
 +- openal input device added
 +- boxblur filter added
  - BWF muxer
  - Flash Screen Video 2 decoder
 -- ffplay/ffprobe/ffserver renamed to avplay/avprobe/avserver
 -- ffmpeg deprecated, added avconv, which is almost the same for now, except
 +- lavfi input device added
 +- added avconv, which is almost the same for now, except
  for a few incompatible changes in the options, which will hopefully make them
  easier to use. The changes are:
      * The options placement is now strictly enforced! While in theory the
@@@ -624,10 -555,10 +624,11 @@@ OBJS-$(CONFIG_MXF_MUXER)               
  OBJS-$(CONFIG_NUT_MUXER)               += mpegaudiodata.o
  OBJS-$(CONFIG_OGG_DEMUXER)             += xiph.o flac.o flacdata.o     \
                                            mpeg12data.o vorbis_parser.o \
 -                                          dirac.o
 -OBJS-$(CONFIG_OGG_MUXER)               += xiph.o flac.o flacdata.o
 +                                          dirac.o vorbis_data.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  \
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -169,8 -161,8 +169,8 @@@ static void jpeg_put_comments(MpegEncCo
      /* 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, 0x0201); /* v 1.02 */
 +    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);
      put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
Simple merge
Simple merge
@@@ -17,11 -16,10 +16,12 @@@ MMX-OBJS                               
  MMX-OBJS-$(CONFIG_AAC_DECODER)         += x86/sbrdsp_init.o
  MMX-OBJS-$(CONFIG_AC3DSP)              += x86/ac3dsp_init.o
  MMX-OBJS-$(CONFIG_CAVS_DECODER)        += x86/cavsdsp.o
 -MMX-OBJS-$(CONFIG_DWT)                 += x86/snowdsp.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
  MMX-OBJS-$(CONFIG_H264PRED)            += x86/h264_intrapred_init.o
  MMX-OBJS-$(CONFIG_LPC)                 += x86/lpc.o
@@@ -121,40 -124,20 +124,42 @@@ static void filter(AVFilterContext *ctx
              h >>= yadif->csp->log2_chroma_h;
          }
  
 +        if(yadif->temp_line_size < absrefs) {
 +            av_free(yadif->temp_line);
 +            yadif->temp_line = av_mallocz(2*64 + 5*absrefs);
 +            yadif->temp_line_size = absrefs;
 +        }
 +
          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;
 +
 +                if(y<=1 || y+2>=h) {
 +                    uint8_t *tmp = yadif->temp_line + 64 + 2*absrefs;
 +                    if(mode<2)
 +                        memcpy(tmp+2*mrefs, cur+2*mrefs, w*df);
 +                    memcpy(tmp+mrefs, cur+mrefs, w*df);
 +                    memcpy(tmp      , cur      , w*df);
 +                    if(prefs != mrefs) {
 +                        memcpy(tmp+prefs, cur+prefs, w*df);
 +                        if(mode<2)
 +                            memcpy(tmp+2*prefs, cur+2*prefs, w*df);
 +                    }
 +                    cur = tmp;
 +                }
 +
-                 yadif->filter_line(dst, prev, cur, next, w, prefs, mrefs, parity ^ tff, mode);
+                 yadif->filter_line(dst, prev, cur, next, w,
 -                                   y + 1 < h ? refs : -refs,
 -                                   y ? -refs : refs,
++                                   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);
              }
          }
      }
@@@ -250,11 -244,11 +254,11 @@@ static int start_frame(AVFilterLink *li
      }
  
      if (!yadif->prev &&
 -        !(yadif->prev = avfilter_ref_buffer(yadif->cur, AV_PERM_READ)))
 +        !(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);
  
@@@ -302,8 -298,10 +308,9 @@@ static int request_frame(AVFilterLink *
  
          ret  = ff_request_frame(link->src->inputs[0]);
  
 -        if (ret == AVERROR_EOF && yadif->next) {
 -            AVFilterBufferRef *next =
 -                avfilter_ref_buffer(yadif->next, AV_PERM_READ);
 +        if (ret == AVERROR_EOF && yadif->cur) {
 +            AVFilterBufferRef *next = avfilter_ref_buffer(yadif->next, ~AV_PERM_WRITE);
              if (!next)
                  return AVERROR(ENOMEM);
  
@@@ -332,7 -330,8 +339,8 @@@ static int poll_frame(AVFilterLink *lin
      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 (val >= 1 && !yadif->next) {
          if ((ret = ff_request_frame(link->src->inputs[0])) < 0)
              return ret;
          val = ff_poll_frame(link->src->inputs[0]);
Simple merge
Simple merge
Simple merge
index 0000000,c77ecbf..0670221
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,331 +1,331 @@@
 - * This file is part of Libav.
+ /*
+  * RTP JPEG-compressed Video Depacketizer, RFC 2435
+  * Copyright (c) 2012 Samuel Pitoiset
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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"
+ #include "rtpdec_formats.h"
+ #include "libavutil/intreadwrite.h"
+ #include "libavcodec/mjpeg.h"
+ /**
+  * RTP/JPEG specific private data.
+  */
+ struct PayloadContext {
+     AVIOContext *frame;         ///< current frame buffer
+     uint32_t    timestamp;      ///< current frame timestamp
+     int         hdr_size;       ///< size of the current frame header
+ };
+ static PayloadContext *jpeg_new_context(void)
+ {
+     return av_mallocz(sizeof(PayloadContext));
+ }
+ static inline void free_frame_if_needed(PayloadContext *jpeg)
+ {
+     if (jpeg->frame) {
+         uint8_t *p;
+         avio_close_dyn_buf(jpeg->frame, &p);
+         av_free(p);
+         jpeg->frame = NULL;
+     }
+ }
+ static void jpeg_free_context(PayloadContext *jpeg)
+ {
+     free_frame_if_needed(jpeg);
+     av_free(jpeg);
+ }
+ static void jpeg_create_huffman_table(PutBitContext *p, int table_class,
+                                       int table_id, const uint8_t *bits_table,
+                                       const uint8_t *value_table)
+ {
+     int i, n = 0;
+     put_bits(p, 8, 0);
+     put_bits(p, 4, table_class);
+     put_bits(p, 4, table_id);
+     for (i = 1; i <= 16; i++) {
+         n += bits_table[i];
+         put_bits(p, 8, bits_table[i]);
+     }
+     for (i = 0; i < n; i++) {
+         put_bits(p, 8, value_table[i]);
+     }
+ }
+ static int jpeg_create_header(uint8_t *buf, int size, uint32_t type, uint32_t w,
+                               uint32_t h, const uint8_t *qtable, int nb_qtable)
+ {
+     PutBitContext pbc;
+     init_put_bits(&pbc, buf, size);
+     /* Convert from blocks to pixels. */
+     w <<= 3;
+     h <<= 3;
+     /* SOI */
+     put_marker(&pbc, SOI);
+     /* JFIF header */
+     put_marker(&pbc, APP0);
+     put_bits(&pbc, 16, 16);
+     avpriv_put_string(&pbc, "JFIF", 1);
+     put_bits(&pbc, 16, 0x0201);
+     put_bits(&pbc, 8, 0);
+     put_bits(&pbc, 16, 1);
+     put_bits(&pbc, 16, 1);
+     put_bits(&pbc, 8, 0);
+     put_bits(&pbc, 8, 0);
+     /* DQT */
+     put_marker(&pbc, DQT);
+     if (nb_qtable == 2) {
+         put_bits(&pbc, 16, 2 + 2 * (1 + 64));
+     } else {
+         put_bits(&pbc, 16, 2 + 1 * (1 + 64));
+     }
+     put_bits(&pbc, 8, 0);
+     /* Each table is an array of 64 values given in zig-zag
+      * order, identical to the format used in a JFIF DQT
+      * marker segment. */
+     avpriv_copy_bits(&pbc, qtable, 64 * 8);
+     if (nb_qtable == 2) {
+         put_bits(&pbc, 8, 1);
+         avpriv_copy_bits(&pbc, qtable + 64, 64 * 8);
+     }
+     /* DHT */
+     put_marker(&pbc, DHT);
+     jpeg_create_huffman_table(&pbc, 0, 0, avpriv_mjpeg_bits_dc_luminance,
+                               avpriv_mjpeg_val_dc);
+     jpeg_create_huffman_table(&pbc, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
+                               avpriv_mjpeg_val_dc);
+     jpeg_create_huffman_table(&pbc, 1, 0, avpriv_mjpeg_bits_ac_luminance,
+                               avpriv_mjpeg_val_ac_luminance);
+     jpeg_create_huffman_table(&pbc, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
+                               avpriv_mjpeg_val_ac_chrominance);
+     /* SOF0 */
+     put_marker(&pbc, SOF0);
+     put_bits(&pbc, 16, 17);
+     put_bits(&pbc, 8, 8);
+     put_bits(&pbc, 8, h >> 8);
+     put_bits(&pbc, 8, h);
+     put_bits(&pbc, 8, w >> 8);
+     put_bits(&pbc, 8, w);
+     put_bits(&pbc, 8, 3);
+     put_bits(&pbc, 8, 1);
+     put_bits(&pbc, 8, type ? 34 : 33);
+     put_bits(&pbc, 8, 0);
+     put_bits(&pbc, 8, 2);
+     put_bits(&pbc, 8, 17);
+     put_bits(&pbc, 8, nb_qtable == 2 ? 1 : 0);
+     put_bits(&pbc, 8, 3);
+     put_bits(&pbc, 8, 17);
+     put_bits(&pbc, 8, nb_qtable == 2 ? 1 : 0);
+     /* SOS */
+     put_marker(&pbc, SOS);
+     put_bits(&pbc, 16, 12);
+     put_bits(&pbc, 8, 3);
+     put_bits(&pbc, 8, 1);
+     put_bits(&pbc, 8, 0);
+     put_bits(&pbc, 8, 2);
+     put_bits(&pbc, 8, 17);
+     put_bits(&pbc, 8, 3);
+     put_bits(&pbc, 8, 17);
+     put_bits(&pbc, 8, 0);
+     put_bits(&pbc, 8, 63);
+     put_bits(&pbc, 8, 0);
+     /* Fill the buffer. */
+     flush_put_bits(&pbc);
+     /* Return the length in bytes of the JPEG header. */
+     return put_bits_count(&pbc) / 8;
+ }
+ static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg,
+                              AVStream *st, AVPacket *pkt, uint32_t *timestamp,
+                              const uint8_t *buf, int len, int flags)
+ {
+     uint8_t type, q, width, height;
+     const uint8_t *qtables = NULL;
+     uint16_t qtable_len;
+     uint32_t off;
+     int ret;
+     if (len < 8) {
+         av_log(ctx, AV_LOG_ERROR, "Too short RTP/JPEG packet.\n");
+         return AVERROR_INVALIDDATA;
+     }
+     /* Parse the main JPEG header. */
+     off    = AV_RB24(buf + 1);  /* fragment byte offset */
+     type   = AV_RB8(buf + 4);   /* id of jpeg decoder params */
+     q      = AV_RB8(buf + 5);   /* quantization factor (or table id) */
+     width  = AV_RB8(buf + 6);   /* frame width in 8 pixel blocks */
+     height = AV_RB8(buf + 7);   /* frame height in 8 pixel blocks */
+     buf += 8;
+     len -= 8;
+     /* Parse the restart marker header. */
+     if (type > 63) {
+         av_log(ctx, AV_LOG_ERROR,
+                "Unimplemented RTP/JPEG restart marker header.\n");
+         return AVERROR_PATCHWELCOME;
+     }
+     /* Parse the quantization table header. */
+     if (q > 127 && off == 0) {
+         uint8_t precision;
+         if (len < 4) {
+             av_log(ctx, AV_LOG_ERROR, "Too short RTP/JPEG packet.\n");
+             return AVERROR_INVALIDDATA;
+         }
+         /* The first byte is reserved for future use. */
+         precision  = AV_RB8(buf + 1);    /* size of coefficients */
+         qtable_len = AV_RB16(buf + 2);   /* length in bytes */
+         buf += 4;
+         len -= 4;
+         if (precision)
+             av_log(ctx, AV_LOG_WARNING, "Only 8-bit precision is supported.\n");
+         if (q == 255 && qtable_len == 0) {
+             av_log(ctx, AV_LOG_ERROR,
+                    "Invalid RTP/JPEG packet. Quantization tables not found.\n");
+             return AVERROR_INVALIDDATA;
+         }
+         if (qtable_len > 0) {
+             if (len < qtable_len) {
+                 av_log(ctx, AV_LOG_ERROR, "Too short RTP/JPEG packet.\n");
+                 return AVERROR_INVALIDDATA;
+             }
+             qtables = buf;
+             buf += qtable_len;
+             len -= qtable_len;
+         }
+     }
+     if (off == 0) {
+         /* Start of JPEG data packet. */
+         uint8_t hdr[1024];
+         /* Skip the current frame in case of the end packet
+          * has been lost somewhere. */
+         free_frame_if_needed(jpeg);
+         if ((ret = avio_open_dyn_buf(&jpeg->frame)) < 0)
+             return ret;
+         jpeg->timestamp = *timestamp;
+         if (!qtables) {
+             av_log(ctx, AV_LOG_ERROR,
+                    "Unimplemented default quantization tables.\n");
+             return AVERROR_PATCHWELCOME;
+         }
+         /* Generate a frame and scan headers that can be prepended to the
+          * RTP/JPEG data payload to produce a JPEG compressed image in
+          * interchange format. */
+         jpeg->hdr_size = jpeg_create_header(hdr, sizeof(hdr), type, width,
+                                             height, qtables,
+                                             qtable_len > 64 ? 2 : 1);
+         /* Copy JPEG header to frame buffer. */
+         avio_write(jpeg->frame, hdr, jpeg->hdr_size);
+     }
+     if (!jpeg->frame) {
+         av_log(ctx, AV_LOG_ERROR,
+                "Received packet without a start chunk; dropping frame.\n");
+         return AVERROR(EAGAIN);
+     }
+     if (jpeg->timestamp != *timestamp) {
+         /* Skip the current frame if timestamp is incorrect.
+          * A start packet has been lost somewhere. */
+         free_frame_if_needed(jpeg);
+         av_log(ctx, AV_LOG_ERROR, "RTP timestamps don't match.\n");
+         return AVERROR_INVALIDDATA;
+     }
+     if (off != avio_tell(jpeg->frame) - jpeg->hdr_size) {
+         av_log(ctx, AV_LOG_ERROR,
+                "Missing packets; dropping frame.\n");
+         return AVERROR(EAGAIN);
+     }
+     /* Copy data to frame buffer. */
+     avio_write(jpeg->frame, buf, len);
+     if (flags & RTP_FLAG_MARKER) {
+         /* End of JPEG data packet. */
+         PutBitContext pbc;
+         uint8_t buf[2];
+         /* Put EOI marker. */
+         init_put_bits(&pbc, buf, sizeof(buf));
+         put_marker(&pbc, EOI);
+         flush_put_bits(&pbc);
+         avio_write(jpeg->frame, buf, sizeof(buf));
+         /* Prepare the JPEG packet. */
+         av_init_packet(pkt);
+         pkt->size = avio_close_dyn_buf(jpeg->frame, &pkt->data);
+         if (pkt->size < 0) {
+             av_log(ctx, AV_LOG_ERROR,
+                    "Error occured when getting frame buffer.\n");
+             jpeg->frame = NULL;
+             return pkt->size;
+         }
+         pkt->stream_index = st->index;
+         pkt->destruct     = av_destruct_packet;
+         /* Re-init the frame buffer. */
+         jpeg->frame = NULL;
+         return 0;
+     }
+     return AVERROR(EAGAIN);
+ }
+ RTPDynamicProtocolHandler ff_jpeg_dynamic_handler = {
+     .enc_name          = "JPEG",
+     .codec_type        = AVMEDIA_TYPE_VIDEO,
+     .codec_id          = AV_CODEC_ID_MJPEG,
+     .alloc             = jpeg_new_context,
+     .free              = jpeg_free_context,
+     .parse_packet      = jpeg_parse_packet,
+     .static_payload_id = 26,
+ };
@@@ -30,8 -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 15
 -#define LIBAVFORMAT_VERSION_MICRO  0
++#define LIBAVFORMAT_VERSION_MINOR 26
++#define LIBAVFORMAT_VERSION_MICRO 100
  
  #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
                                                 LIBAVFORMAT_VERSION_MINOR, \