sigrid/ffmpeg

Changelog+1−0

@@ -8,6 +8,7 @@ version next: · 7 unmodified lines
8	- Apple ProRes encoder	8	- Apple ProRes encoder
9	- ffprobe -count_packets and -count_frames options	9	- ffprobe -count_packets and -count_frames options
10	- Sun Rasterfile Encoder	10	- Sun Rasterfile Encoder
		11	- ID3v2 attached pictures reading and writing
11		12
12		13
13	version 0.10:	14	version 0.10:

doc/APIchanges+8−0

 API changes, most recent first:
+<<<<<<< HEAD
 2012-02-21 - xxxxxxx - lavc 54.4.100
   Add av_get_pcm_codec() function.
 2012-01-24 - xxxxxxx - lavfi 2.60.100
   Add avfilter_graph_dump.
+||||||| merged common ancestors
+=======
+2012-xx-xx - xxxxxxx - lavf 54.2.0 - avformat.h
+  Add AVStream.attached_pic and AV_DISPOSITION_ATTACHED_PIC,
+  used for dealing with attached pictures/cover art.
+>>>>>>> qatar/master
 2012-02-25 - c9bca80 - lavu 51.24.0 - error.h
   Add AVERROR_UNKNOWN

doc/muxers.texi+34−0

@@ -370,5 +370,39 @@ Wrap around segment index once it reaches @var{limit}. · 369 unmodified lines
370	ffmpeg -i in.mkv -c copy -map 0 -f segment -list out.list out%03d.nut	370	ffmpeg -i in.mkv -c copy -map 0 -f segment -list out.list out%03d.nut
371	@end example	371	@end example
372		372
		373	@section mp3
		374
		375	The MP3 muxer writes a raw MP3 stream with an ID3v2 header at the beginning and
		376	optionally an ID3v1 tag at the end. ID3v2.3 and ID3v2.4 are supported, the
		377	@code{id3v2_version} option controls which one is used. The legacy ID3v1 tag is
		378	not written by default, but may be enabled with the @code{write_id3v1} option.
		379
		380	For seekable output the muxer also writes a Xing frame at the beginning, which
		381	contains the number of frames in the file. It is useful for computing duration
		382	of VBR files.
		383
		384	The muxer supports writing ID3v2 attached pictures (APIC frames). The pictures
		385	are supplied to the muxer in form of a video stream with a single packet. There
		386	can be any number of those streams, each will correspond to a single APIC frame.
		387	The stream metadata tags @var{title} and @var{comment} map to APIC
		388	@var{description} and @var{picture type} respectively. See
		389	@url{http://id3.org/id3v2.4.0-frames} for allowed picture types.
		390
		391	Note that the APIC frames must be written at the beginning, so the muxer will
		392	buffer the audio frames until it gets all the pictures. It is therefore advised
		393	to provide the pictures as soon as possible to avoid excessive buffering.
		394
		395	Examples:
		396
		397	Write an mp3 with an ID3v2.3 header and an ID3v1 footer:
		398	@example
		399	ffmpeg -i INPUT -id3v2_version 3 -write_id3v1 1 out.mp3
		400	@end example
		401
		402	Attach a picture to an mp3:
		403	@example
		404	ffmpeg -i input.mp3 -i cover.png -c copy -metadata:s:v title="Album cover"
		405	-metadata:s:v comment="Cover (Front)" out.mp3
		406	@end example
373		407
374	@c man end MUXERS	408	@c man end MUXERS

libavcodec/aacdec.c+84−70

 static const char overread_err[] = "Input buffer exhausted before END element found\n";
-static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
-{
-    // For PCE based channel configurations map the channels solely based on tags.
-    if (!ac->m4ac.chan_config) {
-        return ac->tag_che_map[type][elem_id];
-    }
-    // For indexed channel configurations map the channels solely based on position.
-    switch (ac->m4ac.chan_config) {
-    case 7:
-        if (ac->tags_mapped == 3 && type == TYPE_CPE) {
-            ac->tags_mapped++;
-            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
-        }
-    case 6:
-        /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
-           instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have
-           encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */
-        if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
-            ac->tags_mapped++;
-            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
-        }
-    case 5:
-        if (ac->tags_mapped == 2 && type == TYPE_CPE) {
-            ac->tags_mapped++;
-            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
-        }
-    case 4:
-        if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {
-            ac->tags_mapped++;
-            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
-        }
-    case 3:
-    case 2:
-        if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {
-            ac->tags_mapped++;
-            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
-        } else if (ac->m4ac.chan_config == 2) {
-            return NULL;
-        }
-    case 1:
-        if (!ac->tags_mapped && type == TYPE_SCE) {
-            ac->tags_mapped++;
-            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
-        }
-    default:
-        return NULL;
-    }
-}
 static int count_channels(uint8_t (*layout)[3], int tags)
 {
     int i, sum = 0;
     }
 }
+/**
+ * Set up channel positions based on a default channel configuration
+ * as specified in table 1.17.
+ *
+ * @return  Returns error status. 0 - OK, !0 - error
+ */
+static av_cold int set_default_channel_config(AVCodecContext *avctx,
+                                              uint8_t (*layout_map)[3],
+                                              int *tags,
+                                              int channel_config)
+{
+    if (channel_config < 1 || channel_config > 7) {
+        av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
+               channel_config);
+        return -1;
+    }
+    *tags = tags_per_config[channel_config];
+    memcpy(layout_map, aac_channel_layout_map[channel_config-1], *tags * sizeof(*layout_map));
+    return 0;
+}
+static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
+{
+    // For PCE based channel configurations map the channels solely based on tags.
+    if (!ac->m4ac.chan_config) {
+        return ac->tag_che_map[type][elem_id];
+    }
+    // Allow single CPE stereo files to be signalled with mono configuration.
+    if (!ac->tags_mapped && type == TYPE_CPE && ac->m4ac.chan_config == 1) {
+        uint8_t layout_map[MAX_ELEM_ID*4][3];
+        int layout_map_tags;
+        if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
+                                       2) < 0)
+            return NULL;
+        if (output_configure(ac, layout_map, layout_map_tags,
+                             2, OC_TRIAL_FRAME) < 0)
+            return NULL;
+        ac->m4ac.chan_config = 2;
+    }
+    // For indexed channel configurations map the channels solely based on position.
+    switch (ac->m4ac.chan_config) {
+    case 7:
+        if (ac->tags_mapped == 3 && type == TYPE_CPE) {
+            ac->tags_mapped++;
+            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];
+        }
+    case 6:
+        /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]
+           instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have
+           encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */
+        if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {
+            ac->tags_mapped++;
+            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];
+        }
+    case 5:
+        if (ac->tags_mapped == 2 && type == TYPE_CPE) {
+            ac->tags_mapped++;
+            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];
+        }
+    case 4:
+        if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {
+            ac->tags_mapped++;
+            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];
+        }
+    case 3:
+    case 2:
+        if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {
+            ac->tags_mapped++;
+            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];
+        } else if (ac->m4ac.chan_config == 2) {
+            return NULL;
+        }
+    case 1:
+        if (!ac->tags_mapped && type == TYPE_SCE) {
+            ac->tags_mapped++;
+            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];
+        }
+    default:
+        return NULL;
+    }
+}
 /**
  * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.
  *
     return tags;
 }
-/**
- * Set up channel positions based on a default channel configuration
- * as specified in table 1.17.
- *
- * @return  Returns error status. 0 - OK, !0 - error
- */
-static av_cold int set_default_channel_config(AVCodecContext *avctx,
-                                              uint8_t (*layout_map)[3],
-                                              int *tags,
-                                              int channel_config)
-{
-    if (channel_config < 1 || channel_config > 7) {
-        av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
-               channel_config);
-        return -1;
-    }
-    *tags = tags_per_config[channel_config];
-    memcpy(layout_map, aac_channel_layout_map[channel_config-1], *tags * sizeof(*layout_map));
-    return 0;
-}
 /**
  * Decode GA "General Audio" specific configuration; reference: table 4.1.
  *

libavcodec/ac3enc.c+22−6

     s->bit_alloc.sr_code  = i % 3;
     s->bitstream_id       = s->eac3 ? 16 : 8 + s->bit_alloc.sr_shift;
+    /* select a default bit rate if not set by the user */
+    if (!avctx->bit_rate) {
+        switch (s->fbw_channels) {
+        case 1: avctx->bit_rate =  96000; break;
+        case 2: avctx->bit_rate = 192000; break;
+        case 3: avctx->bit_rate = 320000; break;
+        case 4: avctx->bit_rate = 384000; break;
+        case 5: avctx->bit_rate = 448000; break;
+        }
+    }
     /* validate bit rate */
     if (s->eac3) {
         int max_br, min_br, wpf, min_br_dist, min_br_code;
             wpf--;
         s->frame_size_min = 2 * wpf;
     } else {
+        int best_br = 0, best_code = 0, best_diff = INT_MAX;
         for (i = 0; i < 19; i++) {
-            if ((ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift)*1000 == avctx->bit_rate)
+            int br   = (ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift) * 1000;
+            int diff = abs(br - avctx->bit_rate);
+            if (diff < best_diff) {
+                best_br   = br;
+                best_code = i;
+                best_diff = diff;
+            }
+            if (!best_diff)
                 break;
         }
-        if (i == 19) {
+        avctx->bit_rate    = best_br;
-            av_log(avctx, AV_LOG_ERROR, "invalid bit rate\n");
+        s->frame_size_code = best_code << 1;
-            return AVERROR(EINVAL);
-        }
-        s->frame_size_code = i << 1;
         s->frame_size_min  = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
         s->num_blks_code   = 0x3;
         s->num_blocks      = 6;

libavcodec/ac3enc_fixed.c+1−0

@@ -157,4 +157,5 @@ AVCodec ff_ac3_fixed_encoder = { · 156 unmodified lines
157	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),	157	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
158	.priv_class = &ac3enc_class,	158	.priv_class = &ac3enc_class,
159	.channel_layouts = ff_ac3_channel_layouts,	159	.channel_layouts = ff_ac3_channel_layouts,
		160	.defaults = ac3_defaults,
160	};	161	};

libavcodec/ac3enc_float.c+1−0

@@ -155,5 +155,6 @@ AVCodec ff_ac3_encoder = { · 154 unmodified lines
155	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),	155	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
156	.priv_class = &ac3enc_class,	156	.priv_class = &ac3enc_class,
157	.channel_layouts = ff_ac3_channel_layouts,	157	.channel_layouts = ff_ac3_channel_layouts,
		158	.defaults = ac3_defaults,
158	};	159	};
159	#endif	160	#endif

libavcodec/ac3enc_opts_template.c+6−0

  */
 #include "libavutil/opt.h"
+#include "internal.h"
 #include "ac3.h"
 #if AC3ENC_TYPE == AC3ENC_TYPE_AC3_FIXED
     {"auto", "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.dbl = AC3ENC_OPT_AUTO }, INT_MIN, INT_MAX, AC3ENC_PARAM, "cpl_start_band"},
 {NULL}
 };
+static const AVCodecDefault ac3_defaults[] = {
+    { "b",  "0" },
+    { NULL }
+};

libavcodec/amrnbdec.c+8−0

     p->bad_frame_indicator = !get_bits1(&gb); // quality bit
     skip_bits(&gb, 2);                        // two padding bits
+    if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) {
+        return NO_DATA;
+    }
     if (mode < MODE_DTX)
         ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1,
                            amr_unpacking_bitmaps_per_mode[mode]);
     buf_out = (float *)p->avframe.data[0];
     p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);
+    if (p->cur_frame_mode == NO_DATA) {
+        av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n");
+        return AVERROR_INVALIDDATA;
+    }
     if (p->cur_frame_mode == MODE_DTX) {
         av_log_missing_feature(avctx, "dtx mode", 0);
         av_log(avctx, AV_LOG_INFO, "Note: libopencore_amrnb supports dtx\n");

libavcodec/avcodec.h+20−14

 #define CODEC_FLAG_BITEXACT       0x00800000 ///< Use only bitexact stuff (except (I)DCT).
 /* Fx : Flag for h263+ extra options */
 #define CODEC_FLAG_AC_PRED        0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction
-#define CODEC_FLAG_CBP_RD         0x04000000 ///< Use rate distortion optimization for cbp.
-#define CODEC_FLAG_QP_RD          0x08000000 ///< Use rate distortion optimization for qp selectioon.
 #define CODEC_FLAG_LOOP_FILTER    0x00000800 ///< loop filter
 #define CODEC_FLAG_INTERLACED_ME  0x20000000 ///< interlaced motion estimation
 #define CODEC_FLAG_CLOSED_GOP     0x80000000
 #define CODEC_FLAG2_FAST          0x00000001 ///< Allow non spec compliant speedup tricks.
-#define CODEC_FLAG2_STRICT_GOP    0x00000002 ///< Strictly enforce GOP size.
 #define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.
 #define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.
 #define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
+#if FF_API_MPV_GLOBAL_OPTS
+#define CODEC_FLAG_CBP_RD         0x04000000 ///< Use rate distortion optimization for cbp.
+#define CODEC_FLAG_QP_RD          0x08000000 ///< Use rate distortion optimization for qp selectioon.
+#define CODEC_FLAG2_STRICT_GOP    0x00000002 ///< Strictly enforce GOP size.
 #define CODEC_FLAG2_SKIP_RD       0x00004000 ///< RD optimal MB level residual skipping
+#endif
 #define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
 #define CODEC_FLAG2_SHOW_ALL      0x00400000 ///< Show all frames before the first keyframe
     int b_frame_strategy;
+#if FF_API_MPV_GLOBAL_OPTS
     /**
      * luma single coefficient elimination threshold
      * - encoding: Set by user.
      * - decoding: unused
      */
-    int luma_elim_threshold;
+    attribute_deprecated int luma_elim_threshold;
     /**
      * chroma single coeff elimination threshold
      * - encoding: Set by user.
      * - decoding: unused
      */
-    int chroma_elim_threshold;
+    attribute_deprecated int chroma_elim_threshold;
+#endif
     /**
      * qscale offset between IP and B-frames
      */
     int inter_quant_bias;
+#if FF_API_COLOR_TABLE_ID
     /**
      * color table ID
      * - encoding: unused
      * - decoding: Which clrtable should be used for 8bit RGB images.
      *             Tables have to be stored somewhere. FIXME
      */
-    int color_table_id;
+    attribute_deprecated int color_table_id;
+#endif
     /**
      * slice flags
      */
     int noise_reduction;
+#if FF_API_INTER_THRESHOLD
     /**
-     *
+     * @deprecated this field is unused
-     * - encoding: Set by user.
-     * - decoding: unused
      */
-    int inter_threshold;
+    attribute_deprecated int inter_threshold;
+#endif
+#if FF_API_MPV_GLOBAL_OPTS
     /**
-     * quantizer noise shaping
+     * @deprecated use mpegvideo private options instead
-     * - encoding: Set by user.
-     * - decoding: unused
      */
-    int quantizer_noise_shaping;
+    attribute_deprecated int quantizer_noise_shaping;
+#endif
     /**
      * Motion estimation threshold below which no motion estimation is

libavcodec/cscd.c+2−2

@@ -228,7 +228,7 @@ static av_cold int decode_init(AVCodecContext *avctx) { · 227 unmodified lines
228	av_log(avctx, AV_LOG_ERROR,	228	av_log(avctx, AV_LOG_ERROR,
229	"CamStudio codec error: invalid depth %i bpp\n",	229	"CamStudio codec error: invalid depth %i bpp\n",
230	avctx->bits_per_coded_sample);	230	avctx->bits_per_coded_sample);
231	return 1;	231	return AVERROR_INVALIDDATA;
232	}	232	}
233	c->bpp = avctx->bits_per_coded_sample;	233	c->bpp = avctx->bits_per_coded_sample;
234	avcodec_get_frame_defaults(&c->pic);	234	avcodec_get_frame_defaults(&c->pic);
@@ -242,7 +242,7 @@ static av_cold int decode_init(AVCodecContext *avctx) { · 7 unmodified lines
242	c->decomp_buf = av_malloc(c->decomp_size + AV_LZO_OUTPUT_PADDING);	242	c->decomp_buf = av_malloc(c->decomp_size + AV_LZO_OUTPUT_PADDING);
243	if (!c->decomp_buf) {	243	if (!c->decomp_buf) {
244	av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");	244	av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
245	return 1;	245	return AVERROR(ENOMEM);
246	}	246	}
247	return 0;	247	return 0;
248	}	248	}

libavcodec/dpxenc.c+1−2

     memcpy (buf +   8, "V1.0", 4);
     write32(buf +  20, 1); /* new image */
     write32(buf +  24, HEADER_SIZE);
-    if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
+    if (!(avctx->flags & CODEC_FLAG_BITEXACT))
         memcpy (buf + 160, LIBAVCODEC_IDENT, FFMIN(sizeof(LIBAVCODEC_IDENT), 100));
-    }
     write32(buf + 660, 0xFFFFFFFF); /* unencrypted */
     /* Image information header */

libavcodec/eac3enc.c+1−0

@@ -258,5 +258,6 @@ AVCodec ff_eac3_encoder = { · 257 unmodified lines
258	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 E-AC-3"),	258	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 E-AC-3"),
259	.priv_class = &eac3enc_class,	259	.priv_class = &eac3enc_class,
260	.channel_layouts = ff_ac3_channel_layouts,	260	.channel_layouts = ff_ac3_channel_layouts,
		261	.defaults = ac3_defaults,
261	};	262	};
262	#endif	263	#endif

libavcodec/flvenc.c+3−0

     }
 }
+FF_MPV_GENERIC_CLASS(flv)
 AVCodec ff_flv_encoder = {
     .name           = "flv",
     .type           = AVMEDIA_TYPE_VIDEO,
     .close          = ff_MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"),
+    .priv_class     = &flv_class,
 };

libavcodec/h261enc.c+3−0

     }
 }
+FF_MPV_GENERIC_CLASS(h261)
 AVCodec ff_h261_encoder = {
     .name           = "h261",
     .type           = AVMEDIA_TYPE_VIDEO,
     .close          = ff_MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("H.261"),
+    .priv_class     = &h261_class,
 };

libavcodec/h263.h+1−1

@@ -148,7 +148,7 @@ static inline int get_p_cbp(MpegEncContext * s, · 147 unmodified lines
148	int motion_x, int motion_y){	148	int motion_x, int motion_y){
149	int cbp, i;	149	int cbp, i;
150		150
151	if(s->flags & CODEC_FLAG_CBP_RD){	151	if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
152	int best_cbpy_score= INT_MAX;	152	int best_cbpy_score= INT_MAX;
153	int best_cbpc_score= INT_MAX;	153	int best_cbpc_score= INT_MAX;
154	int cbpc = (-1), cbpy= (-1);	154	int cbpc = (-1), cbpy= (-1);

libavcodec/h264_cabac.c+2−0

@@ -1998,6 +1998,8 @@ decode_intra_mb: · 1997 unmodified lines
1998	}	1998	}
1999		1999
2000	// The pixels are stored in the same order as levels in h->mb array.	2000	// The pixels are stored in the same order as levels in h->mb array.
		2001	if ((int) (h->cabac.bytestream_end - ptr) < mb_size)
		2002	return -1;
2001	memcpy(h->mb, ptr, mb_size); ptr+=mb_size;	2003	memcpy(h->mb, ptr, mb_size); ptr+=mb_size;
2002		2004
2003	ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);	2005	ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);

libavcodec/libvorbis.c+170−138

@@ -20,12 +20,13 @@ · 19 unmodified lines
20		20
21	/**	21	/**
22	* @file	22	* @file
23	* Ogg Vorbis codec support via libvorbisenc.	23	* Vorbis encoding support via libvorbisenc.
24	* @author Mark Hills <mark@pogo.org.uk>	24	* @author Mark Hills <mark@pogo.org.uk>
25	*/	25	*/
26		26
27	#include <vorbis/vorbisenc.h>	27	#include <vorbis/vorbisenc.h>
28		28
		29	#include "libavutil/fifo.h"
29	#include "libavutil/opt.h"	30	#include "libavutil/opt.h"
30	#include "avcodec.h"	31	#include "avcodec.h"
31	#include "bytestream.h"	32	#include "bytestream.h"
@@ -35,32 +36,41 @@ · 3 unmodified lines
35	#undef NDEBUG	36	#undef NDEBUG
36	#include <assert.h>	37	#include <assert.h>
37		38
		39	/* Number of samples the user should send in each call.
		40	* This value is used because it is the LCD of all possible frame sizes, so
		41	* an output packet will always start at the same point as one of the input
		42	* packets.
		43	*/
38	#define OGGVORBIS_FRAME_SIZE 64	44	#define OGGVORBIS_FRAME_SIZE 64
39		45
40	#define BUFFER_SIZE (1024 * 64)	46	#define BUFFER_SIZE (1024 * 64)
41		47
42	typedef struct OggVorbisContext {	48	typedef struct OggVorbisContext {
43	AVClass *av_class;	49	AVClass av_class; /< class for AVOptions /
44	vorbis_info vi;	50	vorbis_info vi; /*< vorbis_info used during init /
45	vorbis_dsp_state vd;	51	vorbis_dsp_state vd; /*< DSP state used for analysis /
46	vorbis_block vb;	52	vorbis_block vb; /*< vorbis_block used for analysis /
47	uint8_t buffer[BUFFER_SIZE];	53	AVFifoBuffer pkt_fifo; /< output packet buffer /
48	int buffer_index;	54	int eof; /*< end-of-file flag /
49	int eof;	55	int dsp_initialized; /*< vd has been initialized /
50		56	vorbis_comment vc; /*< VorbisComment info /
51	/* decoder */	57	ogg_packet op; /*< ogg packet /
52	vorbis_comment vc;	58	double iblock; /*< impulse block bias option /
53	ogg_packet op;
54
55	double iblock;
56	} OggVorbisContext;	59	} OggVorbisContext;
57		60
58	static const AVOption options[] = {	61	static const AVOption options[] = {
59	{ "iblock", "Sets the impulse block bias", offsetof(OggVorbisContext, iblock), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM },	62	{ "iblock", "Sets the impulse block bias", offsetof(OggVorbisContext, iblock), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM },
60	{ NULL }	63	{ NULL }
61	};	64	};
		65
		66	static const AVCodecDefault defaults[] = {
		67	{ "b", "0" },
		68	{ NULL },
		69	};
		70
62	static const AVClass class = { "libvorbis", av_default_item_name, options, LIBAVUTIL_VERSION_INT };	71	static const AVClass class = { "libvorbis", av_default_item_name, options, LIBAVUTIL_VERSION_INT };
63		72
		73
64	static int vorbis_error_to_averror(int ov_err)	74	static int vorbis_error_to_averror(int ov_err)
65	{	75	{
66	switch (ov_err) {	76	switch (ov_err) {
@@ -71,27 +81,34 @@ static int vorbis_error_to_averror(int ov_err) · 4 unmodified lines
71	}	81	}
72	}	82	}
73		83
74	static av_cold int oggvorbis_init_encoder(vorbis_info vi, AVCodecContext avccontext)	84	static av_cold int oggvorbis_init_encoder(vorbis_info *vi,
		85	AVCodecContext *avctx)
75	{	86	{
76	OggVorbisContext *context = avccontext->priv_data;	87	OggVorbisContext *s = avctx->priv_data;
77	double cfreq;	88	double cfreq;
78	int ret;	89	int ret;
79		90
80	if (avccontext->flags & CODEC_FLAG_QSCALE) {	91	if (avctx->flags & CODEC_FLAG_QSCALE \|\| !avctx->bit_rate) {
81	/* variable bitrate */	92	/* variable bitrate
82	float q = avccontext->global_quality / (float)FF_QP2LAMBDA;	93	* NOTE: we use the oggenc range of -1 to 10 for global_quality for
83	if ((ret = vorbis_encode_setup_vbr(vi, avccontext->channels,	94	* user convenience, but libvorbis uses -0.1 to 1.0.
84	avccontext->sample_rate,	95	*/
		96	float q = avctx->global_quality / (float)FF_QP2LAMBDA;
		97	/* default to 3 if the user did not set quality or bitrate */
		98	if (!(avctx->flags & CODEC_FLAG_QSCALE))
		99	q = 3.0;
		100	if ((ret = vorbis_encode_setup_vbr(vi, avctx->channels,
		101	avctx->sample_rate,
85	q / 10.0)))	102	q / 10.0)))
86	goto error;	103	goto error;
87	} else {	104	} else {
88	int minrate = avccontext->rc_min_rate > 0 ? avccontext->rc_min_rate : -1;	105	int minrate = avctx->rc_min_rate > 0 ? avctx->rc_min_rate : -1;
89	int maxrate = avccontext->rc_min_rate > 0 ? avccontext->rc_max_rate : -1;	106	int maxrate = avctx->rc_max_rate > 0 ? avctx->rc_max_rate : -1;
90		107
91	/* constant bitrate */	108	/* average bitrate */
92	if ((ret = vorbis_encode_setup_managed(vi, avccontext->channels,	109	if ((ret = vorbis_encode_setup_managed(vi, avctx->channels,
93	avccontext->sample_rate, minrate,	110	avctx->sample_rate, maxrate,
94	avccontext->bit_rate, maxrate)))	111	avctx->bit_rate, minrate)))
95	goto error;	112	goto error;
96		113
97	/* variable bitrate by estimate, disable slow rate management */	114	/* variable bitrate by estimate, disable slow rate management */
@@ -101,43 +118,44 @@ static av_cold int oggvorbis_init_encoder(vorbis_info vi, AVCodecContext avcco · 3 unmodified lines
101	}	118	}
102		119
103	/* cutoff frequency */	120	/* cutoff frequency */
104	if (avccontext->cutoff > 0) {	121	if (avctx->cutoff > 0) {
105	cfreq = avccontext->cutoff / 1000.0;	122	cfreq = avctx->cutoff / 1000.0;
106	if ((ret = vorbis_encode_ctl(vi, OV_ECTL_LOWPASS_SET, &cfreq)))	123	if ((ret = vorbis_encode_ctl(vi, OV_ECTL_LOWPASS_SET, &cfreq)))
107	goto error; /* should not happen */	124	goto error; /* should not happen */
108	}	125	}
109		126
110	if (context->iblock) {	127	/* impulse block bias */
111	if ((ret = vorbis_encode_ctl(vi, OV_ECTL_IBLOCK_SET, &context->iblock)))	128	if (s->iblock) {
		129	if ((ret = vorbis_encode_ctl(vi, OV_ECTL_IBLOCK_SET, &s->iblock)))
112	goto error;	130	goto error;
113	}	131	}
114		132
115	if (avccontext->channels == 3 &&	133	if (avctx->channels == 3 &&
116	avccontext->channel_layout != (AV_CH_LAYOUT_STEREO\|AV_CH_FRONT_CENTER) \|\|	134	avctx->channel_layout != (AV_CH_LAYOUT_STEREO\|AV_CH_FRONT_CENTER) \|\|
117	avccontext->channels == 4 &&	135	avctx->channels == 4 &&
118	avccontext->channel_layout != AV_CH_LAYOUT_2_2 &&	136	avctx->channel_layout != AV_CH_LAYOUT_2_2 &&
119	avccontext->channel_layout != AV_CH_LAYOUT_QUAD \|\|	137	avctx->channel_layout != AV_CH_LAYOUT_QUAD \|\|
120	avccontext->channels == 5 &&	138	avctx->channels == 5 &&
121	avccontext->channel_layout != AV_CH_LAYOUT_5POINT0 &&	139	avctx->channel_layout != AV_CH_LAYOUT_5POINT0 &&
122	avccontext->channel_layout != AV_CH_LAYOUT_5POINT0_BACK \|\|	140	avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK \|\|
123	avccontext->channels == 6 &&	141	avctx->channels == 6 &&
124	avccontext->channel_layout != AV_CH_LAYOUT_5POINT1 &&	142	avctx->channel_layout != AV_CH_LAYOUT_5POINT1 &&
125	avccontext->channel_layout != AV_CH_LAYOUT_5POINT1_BACK \|\|	143	avctx->channel_layout != AV_CH_LAYOUT_5POINT1_BACK \|\|
126	avccontext->channels == 7 &&	144	avctx->channels == 7 &&
127	avccontext->channel_layout != (AV_CH_LAYOUT_5POINT1\|AV_CH_BACK_CENTER) \|\|	145	avctx->channel_layout != (AV_CH_LAYOUT_5POINT1\|AV_CH_BACK_CENTER) \|\|
128	avccontext->channels == 8 &&	146	avctx->channels == 8 &&
129	avccontext->channel_layout != AV_CH_LAYOUT_7POINT1) {	147	avctx->channel_layout != AV_CH_LAYOUT_7POINT1) {
130	if (avccontext->channel_layout) {	148	if (avctx->channel_layout) {
131	char name[32];	149	char name[32];
132	av_get_channel_layout_string(name, sizeof(name), avccontext->channels,	150	av_get_channel_layout_string(name, sizeof(name), avctx->channels,
133	avccontext->channel_layout);	151	avctx->channel_layout);
134	av_log(avccontext, AV_LOG_ERROR, "%s not supported by Vorbis: "	152	av_log(avctx, AV_LOG_ERROR, "%s not supported by Vorbis: "
135	"output stream will have incorrect "	153	"output stream will have incorrect "
136	"channel layout.\n", name);	154	"channel layout.\n", name);
137	} else {	155	} else {
138	av_log(avccontext, AV_LOG_WARNING, "No channel layout specified. The encoder "	156	av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
139	"will use Vorbis channel layout for "	157	"will use Vorbis channel layout for "
140	"%d channels.\n", avccontext->channels);	158	"%d channels.\n", avctx->channels);
141	}	159	}
142	}	160	}
143		161
@@ -155,59 +173,64 @@ static int xiph_len(int l) · 11 unmodified lines
155	return 1 + l / 255 + l;	173	return 1 + l / 255 + l;
156	}	174	}
157		175
158	static av_cold int oggvorbis_encode_close(AVCodecContext *avccontext)	176	static av_cold int oggvorbis_encode_close(AVCodecContext *avctx)
159	{	177	{
160	OggVorbisContext *context = avccontext->priv_data;	178	OggVorbisContext *s = avctx->priv_data;
161	/* ogg_packet op ; */
162		179
163	vorbis_analysis_wrote(&context->vd, 0); /* notify vorbisenc this is EOF */	180	/* notify vorbisenc this is EOF */
		181	if (s->dsp_initialized)
		182	vorbis_analysis_wrote(&s->vd, 0);
164		183
165	vorbis_block_clear(&context->vb);	184	vorbis_block_clear(&s->vb);
166	vorbis_dsp_clear(&context->vd);	185	vorbis_dsp_clear(&s->vd);
167	vorbis_info_clear(&context->vi);	186	vorbis_info_clear(&s->vi);
168		187
169	av_freep(&avccontext->coded_frame);	188	av_fifo_free(s->pkt_fifo);
170	av_freep(&avccontext->extradata);	189	av_freep(&avctx->coded_frame);
		190	av_freep(&avctx->extradata);
171		191
172	return 0;	192	return 0;
173	}	193	}
174		194
175	static av_cold int oggvorbis_encode_init(AVCodecContext *avccontext)	195	static av_cold int oggvorbis_encode_init(AVCodecContext *avctx)
176	{	196	{
177	OggVorbisContext *context = avccontext->priv_data;	197	OggVorbisContext *s = avctx->priv_data;
178	ogg_packet header, header_comm, header_code;	198	ogg_packet header, header_comm, header_code;
179	uint8_t *p;	199	uint8_t *p;
180	unsigned int offset;	200	unsigned int offset;
181	int ret;	201	int ret;
182		202
183	vorbis_info_init(&context->vi);	203	vorbis_info_init(&s->vi);
184	if ((ret = oggvorbis_init_encoder(&context->vi, avccontext))) {	204	if ((ret = oggvorbis_init_encoder(&s->vi, avctx))) {
185	av_log(avccontext, AV_LOG_ERROR, "oggvorbis_encode_init: init_encoder failed\n");	205	av_log(avctx, AV_LOG_ERROR, "encoder setup failed\n");
186	goto error;	206	goto error;
187	}	207	}
188	if ((ret = vorbis_analysis_init(&context->vd, &context->vi))) {	208	if ((ret = vorbis_analysis_init(&s->vd, &s->vi))) {
		209	av_log(avctx, AV_LOG_ERROR, "analysis init failed\n");
189	ret = vorbis_error_to_averror(ret);	210	ret = vorbis_error_to_averror(ret);
190	goto error;	211	goto error;
191	}	212	}
192	if ((ret = vorbis_block_init(&context->vd, &context->vb))) {	213	s->dsp_initialized = 1;
		214	if ((ret = vorbis_block_init(&s->vd, &s->vb))) {
		215	av_log(avctx, AV_LOG_ERROR, "dsp init failed\n");
193	ret = vorbis_error_to_averror(ret);	216	ret = vorbis_error_to_averror(ret);
194	goto error;	217	goto error;
195	}	218	}
196		219
197	vorbis_comment_init(&context->vc);	220	vorbis_comment_init(&s->vc);
198	vorbis_comment_add_tag(&context->vc, "encoder", LIBAVCODEC_IDENT);	221	vorbis_comment_add_tag(&s->vc, "encoder", LIBAVCODEC_IDENT);
199		222
200	if ((ret = vorbis_analysis_headerout(&context->vd, &context->vc, &header,	223	if ((ret = vorbis_analysis_headerout(&s->vd, &s->vc, &header, &header_comm,
201	&header_comm, &header_code))) {	224	&header_code))) {
202	ret = vorbis_error_to_averror(ret);	225	ret = vorbis_error_to_averror(ret);
203	goto error;	226	goto error;
204	}	227	}
205		228
206	avccontext->extradata_size =	229	avctx->extradata_size = 1 + xiph_len(header.bytes) +
207	1 + xiph_len(header.bytes) + xiph_len(header_comm.bytes) +	230	xiph_len(header_comm.bytes) +
208	header_code.bytes;	231	header_code.bytes;
209	p = avccontext->extradata =	232	p = avctx->extradata = av_malloc(avctx->extradata_size +
210	av_malloc(avccontext->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);	233	FF_INPUT_BUFFER_PADDING_SIZE);
211	if (!p) {	234	if (!p) {
212	ret = AVERROR(ENOMEM);	235	ret = AVERROR(ENOMEM);
213	goto error;	236	goto error;
@@ -222,100 +245,107 @@ static av_cold int oggvorbis_encode_init(AVCodecContext *avccontext) · 8 unmodified lines
222	offset += header_comm.bytes;	245	offset += header_comm.bytes;
223	memcpy(&p[offset], header_code.packet, header_code.bytes);	246	memcpy(&p[offset], header_code.packet, header_code.bytes);
224	offset += header_code.bytes;	247	offset += header_code.bytes;
225	assert(offset == avccontext->extradata_size);	248	assert(offset == avctx->extradata_size);
226		249
227	#if 0	250	vorbis_comment_clear(&s->vc);
228	vorbis_block_clear(&context->vb);
229	vorbis_dsp_clear(&context->vd);
230	vorbis_info_clear(&context->vi);
231	#endif
232	vorbis_comment_clear(&context->vc);
233		251
234	avccontext->frame_size = OGGVORBIS_FRAME_SIZE;	252	avctx->frame_size = OGGVORBIS_FRAME_SIZE;
		253
		254	s->pkt_fifo = av_fifo_alloc(BUFFER_SIZE);
		255	if (!s->pkt_fifo) {
		256	ret = AVERROR(ENOMEM);
		257	goto error;
		258	}
235		259
236	avccontext->coded_frame = avcodec_alloc_frame();	260	avctx->coded_frame = avcodec_alloc_frame();
237	if (!avccontext->coded_frame) {	261	if (!avctx->coded_frame) {
238	ret = AVERROR(ENOMEM);	262	ret = AVERROR(ENOMEM);
239	goto error;	263	goto error;
240	}	264	}
241		265
242	return 0;	266	return 0;
243	error:	267	error:
244	oggvorbis_encode_close(avccontext);	268	oggvorbis_encode_close(avctx);
245	return ret;	269	return ret;
246	}	270	}
247		271
248	static int oggvorbis_encode_frame(AVCodecContext *avccontext,	272	static int oggvorbis_encode_frame(AVCodecContext avctx, unsigned char packets,
249	unsigned char *packets,
250	int buf_size, void *data)	273	int buf_size, void *data)
251	{	274	{
252	OggVorbisContext *context = avccontext->priv_data;	275	OggVorbisContext *s = avctx->priv_data;
253	ogg_packet op;	276	ogg_packet op;
254	signed short *audio = data;	277	float *audio = data;
255	int l;	278	int pkt_size, ret;
256		279
		280	/* send samples to libvorbis */
257	if (data) {	281	if (data) {
258	const int samples = avccontext->frame_size;	282	const int samples = avctx->frame_size;
259	float **buffer;	283	float **buffer;
260	int c, channels = context->vi.channels;	284	int c, channels = s->vi.channels;
261		285
262	buffer = vorbis_analysis_buffer(&context->vd, samples);	286	buffer = vorbis_analysis_buffer(&s->vd, samples);
263	for (c = 0; c < channels; c++) {	287	for (c = 0; c < channels; c++) {
		288	int i;
264	int co = (channels > 8) ? c :	289	int co = (channels > 8) ? c :
265	ff_vorbis_encoding_channel_layout_offsets[channels - 1][c];	290	ff_vorbis_encoding_channel_layout_offsets[channels - 1][c];
266	for (l = 0; l < samples; l++)	291	for (i = 0; i < samples; i++)
267	buffer[c][l] = audio[l * channels + co] / 32768.f;	292	buffer[c][i] = audio[i * channels + co];
		293	}
		294	if ((ret = vorbis_analysis_wrote(&s->vd, samples)) < 0) {
		295	av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
		296	return vorbis_error_to_averror(ret);
268	}	297	}
269	vorbis_analysis_wrote(&context->vd, samples);
270	} else {	298	} else {
271	if (!context->eof)	299	if (!s->eof)
272	vorbis_analysis_wrote(&context->vd, 0);	300	if ((ret = vorbis_analysis_wrote(&s->vd, 0)) < 0) {
273	context->eof = 1;	301	av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
		302	return vorbis_error_to_averror(ret);
		303	}
		304	s->eof = 1;
274	}	305	}
275		306
276	while (vorbis_analysis_blockout(&context->vd, &context->vb) == 1) {	307	/* retrieve available packets from libvorbis */
277	vorbis_analysis(&context->vb, NULL);	308	while ((ret = vorbis_analysis_blockout(&s->vd, &s->vb)) == 1) {
278	vorbis_bitrate_addblock(&context->vb);	309	if ((ret = vorbis_analysis(&s->vb, NULL)) < 0)
279		310	break;
280	while (vorbis_bitrate_flushpacket(&context->vd, &op)) {	311	if ((ret = vorbis_bitrate_addblock(&s->vb)) < 0)
281	/* i'd love to say the following line is a hack, but sadly it's	312	break;
282	* not, apparently the end of stream decision is in libogg. */	313
283	if (op.bytes == 1 && op.e_o_s)	314	/* add any available packets to the output packet buffer */
284	continue;	315	while ((ret = vorbis_bitrate_flushpacket(&s->vd, &op)) == 1) {
285	if (context->buffer_index + sizeof(ogg_packet) + op.bytes > BUFFER_SIZE) {	316	if (av_fifo_space(s->pkt_fifo) < sizeof(ogg_packet) + op.bytes) {
286	av_log(avccontext, AV_LOG_ERROR, "libvorbis: buffer overflow.\n");	317	av_log(avctx, AV_LOG_ERROR, "packet buffer is too small\n");
287	return AVERROR(EINVAL);	318	return AVERROR_BUG;
288	}	319	}
289	memcpy(context->buffer + context->buffer_index, &op, sizeof(ogg_packet));	320	av_fifo_generic_write(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
290	context->buffer_index += sizeof(ogg_packet);	321	av_fifo_generic_write(s->pkt_fifo, op.packet, op.bytes, NULL);
291	memcpy(context->buffer + context->buffer_index, op.packet, op.bytes);	322	}
292	context->buffer_index += op.bytes;	323	if (ret < 0) {
293	// av_log(avccontext, AV_LOG_DEBUG, "e%d / %d\n", context->buffer_index, op.bytes);	324	av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
		325	break;
294	}	326	}
295	}	327	}
		328	if (ret < 0) {
		329	av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
		330	return vorbis_error_to_averror(ret);
		331	}
296		332
297	l = 0;	333	/* output then next packet from the output buffer, if available */
298	if (context->buffer_index) {	334	pkt_size = 0;
299	ogg_packet op2 = (ogg_packet )context->buffer;	335	if (av_fifo_size(s->pkt_fifo) >= sizeof(ogg_packet)) {
300	op2->packet = context->buffer + sizeof(ogg_packet);	336	av_fifo_generic_read(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
301		337	pkt_size = op.bytes;
302	l = op2->bytes;	338	// FIXME: we should use the user-supplied pts and duration
303	avccontext->coded_frame->pts = ff_samples_to_time_base(avccontext,	339	avctx->coded_frame->pts = ff_samples_to_time_base(avctx,
304	op2->granulepos);	340	op.granulepos);
305	//FIXME we should reorder the user supplied pts and not assume that they are spaced by 1/sample_rate	341	if (pkt_size > buf_size) {
306		342	av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
307	if (l > buf_size) {
308	av_log(avccontext, AV_LOG_ERROR, "libvorbis: buffer overflow.\n");
309	return AVERROR(EINVAL);	343	return AVERROR(EINVAL);
310	}	344	}
311		345	av_fifo_generic_read(s->pkt_fifo, packets, pkt_size, NULL);
312	memcpy(packets, op2->packet, l);
313	context->buffer_index -= l + sizeof(ogg_packet);
314	memmove(context->buffer, context->buffer + l + sizeof(ogg_packet), context->buffer_index);
315	// av_log(avccontext, AV_LOG_DEBUG, "E%d\n", l);
316	}	346	}
317		347
318	return l;	348	return pkt_size;
319	}	349	}
320		350
321	AVCodec ff_libvorbis_encoder = {	351	AVCodec ff_libvorbis_encoder = {
@@ -327,7 +357,9 @@ AVCodec ff_libvorbis_encoder = { · 5 unmodified lines
327	.encode = oggvorbis_encode_frame,	357	.encode = oggvorbis_encode_frame,
328	.close = oggvorbis_encode_close,	358	.close = oggvorbis_encode_close,
329	.capabilities = CODEC_CAP_DELAY,	359	.capabilities = CODEC_CAP_DELAY,
330	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },	360	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
		361	AV_SAMPLE_FMT_NONE },
331	.long_name = NULL_IF_CONFIG_SMALL("libvorbis Vorbis"),	362	.long_name = NULL_IF_CONFIG_SMALL("libvorbis Vorbis"),
332	.priv_class = &class,	363	.priv_class = &class,
		364	.defaults = defaults,
333	};	365	};

libavcodec/mpeg12enc.c+2−0

 static const AVOption mpeg1_options[] = {
     COMMON_OPTS
+    FF_MPV_COMMON_OPTS
     { NULL },
 };
     COMMON_OPTS
     { "non_linear_quant",    "Use nonlinear quantizer.",          OFFSET(q_scale_type),         AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
     { "alternate_scan",      "Enable alternate scantable.",       OFFSET(alternate_scan),       AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
+    FF_MPV_COMMON_OPTS
     { NULL },
 };

libavcodec/mpeg4videoenc.c+2−1

 {
     int cbp = 0, i;
-    if (s->flags & CODEC_FLAG_CBP_RD) {
+    if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
         int score = 0;
         const int lambda = s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
 static const AVOption options[] = {
     { "data_partitioning",       "Use data partitioning.",      OFFSET(data_partitioning), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
     { "alternate_scan",          "Enable alternate scantable.", OFFSET(alternate_scan),    AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
+    FF_MPV_COMMON_OPTS
     { NULL },
 };

libavcodec/mpegaudiodec.c+7−0

 #include "get_bits.h"
 #include "mathops.h"
 #include "mpegaudiodsp.h"
+#include "dsputil.h"
 /*
  * TODO:
     int err_recognition;
     AVCodecContext* avctx;
     MPADSPContext mpadsp;
+    DSPContext dsp;
     AVFrame frame;
 } MPADecodeContext;
     s->avctx = avctx;
     ff_mpadsp_init(&s->mpadsp);
+    ff_dsputil_init(&s->dsp, avctx);
     avctx->sample_fmt= OUT_FMT;
     s->err_recognition = avctx->err_recognition;
         /* ms stereo ONLY */
         /* NOTE: the 1/sqrt(2) normalization factor is included in the
            global gain */
+#if CONFIG_FLOAT
+       s-> dsp.butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
+#else
         tab0 = g0->sb_hybrid;
         tab1 = g1->sb_hybrid;
         for (i = 0; i < 576; i++) {
             tab0[i] = tmp0 + tmp1;
             tab1[i] = tmp0 - tmp1;
         }
+#endif
     }
 }

libavcodec/mpegvideo.h+35−0

@@ -38,6 +38,8 @@ · 37 unmodified lines
38	#include "rl.h"	38	#include "rl.h"
39	#include "libavutil/timecode.h"	39	#include "libavutil/timecode.h"
40		40
		41	#include "libavutil/opt.h"
		42
41	#define FRAME_SKIPPED 100 ///< return value for header parsers if frame is not coded	43	#define FRAME_SKIPPED 100 ///< return value for header parsers if frame is not coded
42		44
43	enum OutputFormat {	45	enum OutputFormat {
@@ -695,6 +697,9 @@ typedef struct MpegEncContext { · 651 unmodified lines
695	int (dct_quantize)(struct MpegEncContext s, DCTELEM block/align 16/, int n, int qscale, int overflow);	697	int (dct_quantize)(struct MpegEncContext s, DCTELEM block/align 16/, int n, int qscale, int overflow);
696	int (fast_dct_quantize)(struct MpegEncContext s, DCTELEM block/align 16/, int n, int qscale, int overflow);	698	int (fast_dct_quantize)(struct MpegEncContext s, DCTELEM block/align 16/, int n, int qscale, int overflow);
697	void (denoise_dct)(struct MpegEncContext s, DCTELEM *block);	699	void (denoise_dct)(struct MpegEncContext s, DCTELEM *block);
		700
		701	int mpv_flags; ///< flags set by private options
		702	int quantizer_noise_shaping;
698	} MpegEncContext;	703	} MpegEncContext;
699		704
700	#define REBASE_PICTURE(pic, new_ctx, old_ctx) (pic ? \	705	#define REBASE_PICTURE(pic, new_ctx, old_ctx) (pic ? \
@@ -702,6 +707,36 @@ typedef struct MpegEncContext { · 1 unmodified line
702	&new_ctx->picture[pic - old_ctx->picture] : pic - (Picture)old_ctx + (Picture)new_ctx)\	707	&new_ctx->picture[pic - old_ctx->picture] : pic - (Picture)old_ctx + (Picture)new_ctx)\
703	: NULL)	708	: NULL)
704		709
		710	/* mpegvideo_enc common options */
		711	#define FF_MPV_FLAG_SKIP_RD 0x0001
		712	#define FF_MPV_FLAG_STRICT_GOP 0x0002
		713	#define FF_MPV_FLAG_QP_RD 0x0004
		714	#define FF_MPV_FLAG_CBP_RD 0x0008
		715
		716	#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
		717	#define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM)
		718	#define FF_MPV_COMMON_OPTS \
		719	{ "mpv_flags", "Flags common for all mpegvideo-based encoders.", FF_MPV_OFFSET(mpv_flags), AV_OPT_TYPE_FLAGS, { 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "mpv_flags" },\
		720	{ "skip_rd", "RD optimal MB level residual skipping", 0, AV_OPT_TYPE_CONST, { FF_MPV_FLAG_SKIP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
		721	{ "strict_gop", "Strictly enforce gop size", 0, AV_OPT_TYPE_CONST, { FF_MPV_FLAG_STRICT_GOP }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
		722	{ "qp_rd", "Use rate distortion optimization for qp selection", 0, AV_OPT_TYPE_CONST, { FF_MPV_FLAG_QP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
		723	{ "cbp_rd", "use rate distortion optimization for CBP", 0, AV_OPT_TYPE_CONST, { FF_MPV_FLAG_CBP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
		724	{ "luma_elim_threshold", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\
		725	FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
		726	{ "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\
		727	FF_MPV_OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, { 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
		728	{ "quantizer_noise_shaping", NULL, FF_MPV_OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, { 0 }, 0, INT_MAX, FF_MPV_OPT_FLAGS },
		729
		730	extern const AVOption ff_mpv_generic_options[];
		731
		732	#define FF_MPV_GENERIC_CLASS(name) \
		733	static const AVClass name ## _class = {\
		734	.class_name = #name " encoder",\
		735	.item_name = av_default_item_name,\
		736	.option = ff_mpv_generic_options,\
		737	.version = LIBAVUTIL_VERSION_INT,\
		738	};
		739
705	void ff_MPV_decode_defaults(MpegEncContext *s);	740	void ff_MPV_decode_defaults(MpegEncContext *s);
706	int ff_MPV_common_init(MpegEncContext *s);	741	int ff_MPV_common_init(MpegEncContext *s);
707	void ff_MPV_common_end(MpegEncContext *s);	742	void ff_MPV_common_end(MpegEncContext *s);

libavcodec/mpegvideo_enc.c+56−17

 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
+const AVOption ff_mpv_generic_options[] = {
+    FF_MPV_COMMON_OPTS
+    { NULL },
+};
 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
                        uint16_t (*qmat16)[2][64],
                        const uint16_t *quant_matrix,
     s->flags2       = avctx->flags2;
     s->max_b_frames = avctx->max_b_frames;
     s->codec_id     = avctx->codec->id;
-    s->luma_elim_threshold   = avctx->luma_elim_threshold;
+#if FF_API_MPV_GLOBAL_OPTS
-    s->chroma_elim_threshold = avctx->chroma_elim_threshold;
+    if (avctx->luma_elim_threshold)
+        s->luma_elim_threshold   = avctx->luma_elim_threshold;
+    if (avctx->chroma_elim_threshold)
+        s->chroma_elim_threshold = avctx->chroma_elim_threshold;
+#endif
     s->strict_std_compliance = avctx->strict_std_compliance;
     s->quarter_sample     = (avctx->flags & CODEC_FLAG_QPEL) != 0;
     s->mpeg_quant         = avctx->mpeg_quant;
     /* Fixed QSCALE */
     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
+#if FF_API_MPV_GLOBAL_OPTS
+    if (s->flags & CODEC_FLAG_QP_RD)
+        s->mpv_flags |= FF_MPV_FLAG_QP_RD;
+#endif
     s->adaptive_quant = (s->avctx->lumi_masking ||
                          s->avctx->dark_masking ||
                          s->avctx->temporal_cplx_masking ||
                          s->avctx->spatial_cplx_masking  ||
                          s->avctx->p_masking      ||
                          s->avctx->border_masking ||
-                         (s->flags & CODEC_FLAG_QP_RD)) &&
+                         (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
                         !s->fixed_qscale;
     s->loop_filter      = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
         return -1;
     }
-    if ((s->flags & CODEC_FLAG_CBP_RD) && !avctx->trellis) {
+#if FF_API_MPV_GLOBAL_OPTS
+    if (s->flags & CODEC_FLAG_CBP_RD)
+        s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
+#endif
+    if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
         return -1;
     }
-    if ((s->flags & CODEC_FLAG_QP_RD) &&
+    if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
         s->avctx->mb_decision != FF_MB_DECISION_RD) {
         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
         return -1;
     }
     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
+#if FF_API_MPV_GLOBAL_OPTS
+    if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
+        s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
+    if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
+        s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
+    if (avctx->quantizer_noise_shaping)
+        s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
+#endif
     switch (avctx->codec->id) {
     case CODEC_ID_MPEG1VIDEO:
         s->out_format = FMT_MPEG1;
             }
             if (s->picture_in_gop_number + b_frames >= s->gop_size) {
-                if ((s->flags2 & CODEC_FLAG2_STRICT_GOP) &&
+                if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
                     s->gop_size > s->picture_in_gop_number) {
                     b_frames = s->gop_size - s->picture_in_gop_number - 1;
                 } else {
         s->lambda = s->lambda_table[mb_xy];
         update_qscale(s);
-        if (!(s->flags & CODEC_FLAG_QP_RD)) {
+        if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
             s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
             s->dquant = s->qscale - last_qp;
             }
         }
         ff_set_qscale(s, last_qp + s->dquant);
-    } else if (s->flags & CODEC_FLAG_QP_RD)
+    } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
         ff_set_qscale(s, s->qscale + s->dquant);
     wrap_y = s->linesize;
         }
     }
-    if (s->avctx->quantizer_noise_shaping) {
+    if (s->quantizer_noise_shaping) {
         if (!skip_dct[0])
             get_visual_weight(weight[0], ptr_y                 , wrap_y);
         if (!skip_dct[1])
             } else
                 s->block_last_index[i] = -1;
         }
-        if (s->avctx->quantizer_noise_shaping) {
+        if (s->quantizer_noise_shaping) {
             for (i = 0; i < mb_block_count; i++) {
                 if (!skip_dct[i]) {
                     s->block_last_index[i] =
             for (i = 4; i < mb_block_count; i++)
                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
-        if (s->flags & CODEC_FLAG_CBP_RD) {
+        if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
             for (i = 0; i < mb_block_count; i++) {
                 if (s->block_last_index[i] == -1)
                     s->coded_score[i] = INT_MAX / 256;
             s->mb_skipped=0;
             s->dquant=0; //only for QP_RD
-            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
+            if (mb_type & (mb_type-1) || (s->mpv_flags & FF_MPV_FLAG_QP_RD)) { // more than 1 MB type possible or FF_MPV_FLAG_QP_RD
                 int next_block=0;
                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
                     }
                 }
-                if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){
+                if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
                     if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
                         const int last_qp= backup_s.qscale;
                         int qpi, qp, dc[6];
                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
-                if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){
+                if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
                     int coded=0;
                     for(i=0; i<6; i++)
                         coded |= s->block_last_index[i];
 #ifdef REFINE_STATS
 {START_TIMER
 #endif
-        analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
+        analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
         if(analyze_gradient){
 #ifdef REFINE_STATS
             const int level= block[j];
             int change, old_coeff;
-            if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
+            if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
                 break;
             if(level){
                 int score, new_coeff, unquant_change;
                 score=0;
-                if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
+                if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
                    continue;
                 if(new_level){
 static const AVOption h263_options[] = {
     { "obmc",         "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
     { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
+    FF_MPV_COMMON_OPTS
     { NULL },
 };
     { "aiv",        "Use alternative inter VLC.",       OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
     { "obmc",       "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
     { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
+    FF_MPV_COMMON_OPTS
     { NULL },
 };
 static const AVClass h263p_class = {
     .priv_class     = &h263p_class,
 };
+FF_MPV_GENERIC_CLASS(msmpeg4v2)
 AVCodec ff_msmpeg4v2_encoder = {
     .name           = "msmpeg4v2",
     .type           = AVMEDIA_TYPE_VIDEO,
     .close          = ff_MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
+    .priv_class     = &msmpeg4v2_class,
 };
+FF_MPV_GENERIC_CLASS(msmpeg4v3)
 AVCodec ff_msmpeg4v3_encoder = {
     .name           = "msmpeg4",
     .type           = AVMEDIA_TYPE_VIDEO,
     .close          = ff_MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
+    .priv_class     = &msmpeg4v3_class,
 };
+FF_MPV_GENERIC_CLASS(wmv1)
 AVCodec ff_wmv1_encoder = {
     .name           = "wmv1",
     .type           = AVMEDIA_TYPE_VIDEO,
     .close          = ff_MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
+    .priv_class     = &wmv1_class,
 };

libavcodec/options.c+21−7

 {"global_header", "place global headers in extradata instead of every keyframe", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V|A|E, "flags"},
 {"bitexact", "use only bitexact stuff (except (i)dct)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_BITEXACT }, INT_MIN, INT_MAX, A|V|S|D|E, "flags"},
 {"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_AC_PRED }, INT_MIN, INT_MAX, V|E, "flags"},
-{"cbp", "use rate distortion optimization for cbp", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_CBP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
+#if FF_API_MPV_GLOBAL_OPTS
-{"qprd", "use rate distortion optimization for qp selection", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
+{"cbp", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_CBP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
+{"qprd", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
+#endif
 {"ilme", "interlaced motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_INTERLACED_ME }, INT_MIN, INT_MAX, V|E, "flags"},
 {"cgop", "closed gop", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_CLOSED_GOP }, INT_MIN, INT_MAX, V|E, "flags"},
 {"fast", "allow non spec compliant speedup tricks", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_FAST }, INT_MIN, INT_MAX, V|E, "flags2"},
-{"sgop", "strictly enforce gop size", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_STRICT_GOP }, INT_MIN, INT_MAX, V|E, "flags2"},
+#if FF_API_MPV_GLOBAL_OPTS
+{"sgop", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_STRICT_GOP }, INT_MIN, INT_MAX, V|E, "flags2"},
+#endif
 {"noout", "skip bitstream encoding", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_NO_OUTPUT }, INT_MIN, INT_MAX, V|E, "flags2"},
 {"local_header", "place global headers at every keyframe instead of in extradata", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_LOCAL_HEADER }, INT_MIN, INT_MAX, V|E, "flags2"},
 {"showall", "Show all frames before the first keyframe", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SHOW_ALL }, INT_MIN, INT_MAX, V|D, "flags2"},
 {"dc_clip", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_DC_CLIP }, INT_MIN, INT_MAX, V|D, "bug"},
 {"ms", "workaround various bugs in microsofts broken decoders", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_MS }, INT_MIN, INT_MAX, V|D, "bug"},
 {"trunc", "trancated frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_BUG_TRUNCATED}, INT_MIN, INT_MAX, V|D, "bug"},
+#if FF_API_MPV_GLOBAL_OPTS
 {"lelim", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)", OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
 {"celim", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)", OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+#endif
 {"strict", "how strictly to follow the standards", OFFSET(strict_std_compliance), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 {"very", "strictly conform to a older more strict version of the spec or reference software", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_VERY_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
 {"strict", "strictly conform to all the things in the spec no matter what consequences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
 {"rc_qmod_freq", "experimental quantizer modulation", OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
 {"rc_override_count", NULL, OFFSET(rc_override_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
 {"rc_eq", "set rate control equation", OFFSET(rc_eq), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, V|E},
-{"maxrate", "set max video bitrate tolerance (in bits/s)", OFFSET(rc_max_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+{"maxrate", "set max bitrate tolerance (in bits/s)", OFFSET(rc_max_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
-{"minrate", "set min video bitrate tolerance (in bits/s)", OFFSET(rc_min_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+{"minrate", "set min bitrate tolerance (in bits/s)", OFFSET(rc_min_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
 {"bufsize", "set ratecontrol buffer size (in bits)", OFFSET(rc_buffer_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|V|E},
 {"rc_buf_aggressivity", "currently useless", OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, V|E},
 {"i_qfactor", "qp factor between P and I frames", OFFSET(i_quant_factor), AV_OPT_TYPE_FLOAT, {.dbl = -0.8 }, -FLT_MAX, FLT_MAX, V|E},
 {"me_range", "limit motion vectors range (1023 for DivX player)", OFFSET(me_range), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
 {"ibias", "intra quant bias", OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.dbl = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, V|E},
 {"pbias", "inter quant bias", OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.dbl = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, V|E},
+#if FF_API_COLOR_TABLE_ID
 {"color_table_id", NULL, OFFSET(color_table_id), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
+#endif
 {"global_quality", NULL, OFFSET(global_quality), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
 {"coder", NULL, OFFSET(coder_type), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "coder"},
 {"vlc", "variable length coder / huffman coder", 0, AV_OPT_TYPE_CONST, {.dbl = FF_CODER_TYPE_VLC }, INT_MIN, INT_MAX, V|E, "coder"},
 {"lmax", "max lagrange factor (VBR)", OFFSET(lmax), AV_OPT_TYPE_INT, {.dbl = 31*FF_QP2LAMBDA }, 0, INT_MAX, V|E},
 {"nr", "noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
 {"rc_init_occupancy", "number of bits which should be loaded into the rc buffer before decoding starts", OFFSET(rc_initial_buffer_occupancy), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+#if FF_API_INTER_THRESHOLD
 {"inter_threshold", NULL, OFFSET(inter_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+#endif
 {"flags2", NULL, OFFSET(flags2), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT}, 0, UINT_MAX, V|A|E|D, "flags2"},
 {"error", NULL, OFFSET(error_rate), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
-{"qns", "quantizer noise shaping", OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+#if FF_API_MPV_GLOBAL_OPTS
+{"qns", "deprecated, use mpegvideo private options instead", OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
+#endif
 {"threads", NULL, OFFSET(thread_count), AV_OPT_TYPE_INT, {.dbl = 1 }, 0, INT_MAX, V|E|D, "threads"},
 {"auto", "detect a good number of threads", 0, AV_OPT_TYPE_CONST, {.dbl = 0 }, INT_MIN, INT_MAX, V|E|D, "threads"},
 {"me_threshold", "motion estimaton threshold", OFFSET(me_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
 {"refs", "reference frames to consider for motion compensation", OFFSET(refs), AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
 {"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
 {"trellis", "rate-distortion optimal quantization", OFFSET(trellis), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
-{"skiprd", "RD optimal MB level residual skipping", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SKIP_RD }, INT_MIN, INT_MAX, V|E, "flags2"},
+#if FF_API_MPV_GLOBAL_OPTS
+{"skiprd", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SKIP_RD }, INT_MIN, INT_MAX, V|E, "flags2"},
+#endif
 {"sc_factor", "multiplied by qscale for each frame and added to scene_change_score", OFFSET(scenechange_factor), AV_OPT_TYPE_INT, {.dbl = 6 }, 0, INT_MAX, V|E},
 {"mv0_threshold", NULL, OFFSET(mv0_threshold), AV_OPT_TYPE_INT, {.dbl = 256 }, 0, INT_MAX, V|E},
 {"b_sensitivity", "adjusts sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.dbl = 40 }, 1, INT_MAX, V|E},

libavcodec/proresdec_lgpl.c+32−13

         ctx->picture.top_field_first  = ctx->frame_type & 1;
     }
+    avctx->color_primaries = buf[14];
+    avctx->color_trc       = buf[15];
+    avctx->colorspace      = buf[16];
     ctx->alpha_info = buf[17] & 0xf;
     if (ctx->alpha_info)
         av_log_missing_feature(avctx, "alpha channel", 0);
                                int data_size, uint16_t *out_ptr,
                                int linesize, int mbs_per_slice,
                                int blocks_per_mb, int plane_size_factor,
-                               const int16_t *qmat)
+                               const int16_t *qmat, int is_chroma)
 {
     GetBitContext gb;
     DCTELEM *block_ptr;
     /* inverse quantization, inverse transform and output */
     block_ptr = td->blocks;
-    for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
+    if (!is_chroma) {
-        ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
+        for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
-        block_ptr += 64;
+            ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
-        if (blocks_per_mb > 2) {
+            block_ptr += 64;
-            ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
+            if (blocks_per_mb > 2) {
+                ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
+                block_ptr += 64;
+            }
+            ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
             block_ptr += 64;
+            if (blocks_per_mb > 2) {
+                ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
+                block_ptr += 64;
+            }
         }
-        ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
+    } else {
-        block_ptr += 64;
+        for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
-        if (blocks_per_mb > 2) {
+            ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
-            ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
+            block_ptr += 64;
+            ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
             block_ptr += 64;
+            if (blocks_per_mb > 2) {
+                ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
+                block_ptr += 64;
+                ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
+                block_ptr += 64;
+            }
         }
     }
 }
                        (uint16_t*) (y_data + (mb_y_pos << 4) * y_linesize +
                                     (mb_x_pos << 5)), y_linesize,
                        mbs_per_slice, 4, slice_width_factor + 2,
-                       td->qmat_luma_scaled);
+                       td->qmat_luma_scaled, 0);
     /* decode U chroma plane */
     decode_slice_plane(ctx, td, buf + hdr_size + y_data_size, u_data_size,
                                     (mb_x_pos << ctx->mb_chroma_factor)),
                        u_linesize, mbs_per_slice, ctx->num_chroma_blocks,
                        slice_width_factor + ctx->chroma_factor - 1,
-                       td->qmat_chroma_scaled);
+                       td->qmat_chroma_scaled, 1);
     /* decode V chroma plane */
     decode_slice_plane(ctx, td, buf + hdr_size + y_data_size + u_data_size,
                                     (mb_x_pos << ctx->mb_chroma_factor)),
                        v_linesize, mbs_per_slice, ctx->num_chroma_blocks,
                        slice_width_factor + ctx->chroma_factor - 1,
-                       td->qmat_chroma_scaled);
+                       td->qmat_chroma_scaled, 1);
     return 0;
 }

libavcodec/proresenc_kostya.c+35−22

 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
                            int linesize, int x, int y, int w, int h,
                            DCTELEM *blocks,
-                           int mbs_per_slice, int blocks_per_mb)
+                           int mbs_per_slice, int blocks_per_mb, int is_chroma)
 {
     const uint16_t *esrc;
     const int mb_width = 4 * blocks_per_mb;
             elinesize = linesize;
         } else {
             int bw, bh, pix;
-            const int estride = 16 / sizeof(*ctx->emu_buf);
             esrc      = ctx->emu_buf;
-            elinesize = 16;
+            elinesize = 16 * sizeof(*ctx->emu_buf);
             bw = FFMIN(w - x, mb_width);
             bh = FFMIN(h - y, 16);
             for (j = 0; j < bh; j++) {
-                memcpy(ctx->emu_buf + j * estride, src + j * linesize,
+                memcpy(ctx->emu_buf + j * 16,
+                       (const uint8_t*)src + j * linesize,
                        bw * sizeof(*src));
-                pix = ctx->emu_buf[j * estride + bw - 1];
+                pix = ctx->emu_buf[j * 16 + bw - 1];
                 for (k = bw; k < mb_width; k++)
-                    ctx->emu_buf[j * estride + k] = pix;
+                    ctx->emu_buf[j * 16 + k] = pix;
             }
             for (; j < 16; j++)
-                memcpy(ctx->emu_buf + j * estride,
+                memcpy(ctx->emu_buf + j * 16,
-                       ctx->emu_buf + (bh - 1) * estride,
+                       ctx->emu_buf + (bh - 1) * 16,
                        mb_width * sizeof(*ctx->emu_buf));
         }
-        ctx->dsp.fdct(esrc, elinesize, blocks);
+        if (!is_chroma) {
-        blocks += 64;
+            ctx->dsp.fdct(esrc, elinesize, blocks);
-        if (blocks_per_mb > 2) {
-            ctx->dsp.fdct(src + 8, linesize, blocks);
             blocks += 64;
-        }
+            if (blocks_per_mb > 2) {
-        ctx->dsp.fdct(src + linesize * 4, linesize, blocks);
+                ctx->dsp.fdct(src + 8, linesize, blocks);
-        blocks += 64;
+                blocks += 64;
-        if (blocks_per_mb > 2) {
+            }
-            ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);
+            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);
             blocks += 64;
+            if (blocks_per_mb > 2) {
+                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);
+                blocks += 64;
+            }
+        } else {
+            ctx->dsp.fdct(esrc, elinesize, blocks);
+            blocks += 64;
+            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);
+            blocks += 64;
+            if (blocks_per_mb > 2) {
+                ctx->dsp.fdct(src + 8, linesize, blocks);
+                blocks += 64;
+                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);
+                blocks += 64;
+            }
         }
         x += mb_width;
         get_slice_data(ctx, src, pic->linesize[i], xp, yp,
                        pwidth, avctx->height, ctx->blocks[0],
-                       mbs_per_slice, num_cblocks);
+                       mbs_per_slice, num_cblocks, is_chroma);
         sizes[i] = encode_slice_plane(ctx, pb, src, pic->linesize[i],
                                       mbs_per_slice, ctx->blocks[0],
                                       num_cblocks, plane_factor,
         get_slice_data(ctx, src, pic->linesize[i], xp, yp,
                        pwidth, avctx->height, ctx->blocks[i],
-                       mbs_per_slice, num_cblocks[i]);
+                       mbs_per_slice, num_cblocks[i], is_chroma[i]);
     }
     for (q = min_quant; q < max_quant + 2; q++) {
     bytestream_put_be16  (&buf, avctx->height);
     bytestream_put_byte  (&buf, ctx->chroma_factor << 6); // frame flags
     bytestream_put_byte  (&buf, 0);             // reserved
-    bytestream_put_byte  (&buf, 0);             // primaries
+    bytestream_put_byte  (&buf, avctx->color_primaries);
-    bytestream_put_byte  (&buf, 0);             // transfer function
+    bytestream_put_byte  (&buf, avctx->color_trc);
-    bytestream_put_byte  (&buf, 6);             // colour matrix - ITU-R BT.601-4
+    bytestream_put_byte  (&buf, avctx->colorspace);
     bytestream_put_byte  (&buf, 0x40);          // source format and alpha information
     bytestream_put_byte  (&buf, 0);             // reserved
     bytestream_put_byte  (&buf, 0x03);          // matrix flags - both matrices are present

libavcodec/qtrle.c+1−1

@@ -424,7 +424,7 @@ static av_cold int qtrle_decode_init(AVCodecContext *avctx) · 423 unmodified lines
424	default:	424	default:
425	av_log (avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",	425	av_log (avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
426	avctx->bits_per_coded_sample);	426	avctx->bits_per_coded_sample);
427	break;	427	return AVERROR_INVALIDDATA;
428	}	428	}
429		429
430	avcodec_get_frame_defaults(&s->frame);	430	avcodec_get_frame_defaults(&s->frame);

libavcodec/rpza.c+4−0

             color4[1] |= ((11 * ta + 21 * tb) >> 5);
             color4[2] |= ((21 * ta + 11 * tb) >> 5);
+            if (s->size - stream_ptr < n_blocks * 4)
+                return;
             while (n_blocks--) {
                 block_ptr = row_ptr + pixel_ptr;
                 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
         /* Fill block with 16 colors */
         case 0x00:
+            if (s->size - stream_ptr < 16)
+                return;
             block_ptr = row_ptr + pixel_ptr;
             for (pixel_y = 0; pixel_y < 4; pixel_y++) {
                 for (pixel_x = 0; pixel_x < 4; pixel_x++){

libavcodec/rv10enc.c+3−0

     put_bits(&s->pb, 3, 0);     /* ignored */
 }
+FF_MPV_GENERIC_CLASS(rv10)
 AVCodec ff_rv10_encoder = {
     .name           = "rv10",
     .type           = AVMEDIA_TYPE_VIDEO,
     .close          = ff_MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
+    .priv_class     = &rv10_class,
 };

libavcodec/rv20enc.c+3−0

     }
 }
+FF_MPV_GENERIC_CLASS(rv20)
 AVCodec ff_rv20_encoder = {
     .name           = "rv20",
     .type           = AVMEDIA_TYPE_VIDEO,
     .close          = ff_MPV_encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
+    .priv_class     = &rv20_class,
 };

libavcodec/version.h+9−0

@@ -60,5 +60,14 @@ · 59 unmodified lines
60	#ifndef FF_API_OLD_ENCODE_VIDEO	60	#ifndef FF_API_OLD_ENCODE_VIDEO
61	#define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 55)	61	#define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 55)
62	#endif	62	#endif
		63	#ifndef FF_API_MPV_GLOBAL_OPTS
		64	#define FF_API_MPV_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 55)
		65	#endif
		66	#ifndef FF_API_COLOR_TABLE_ID
		67	#define FF_API_COLOR_TABLE_ID (LIBAVCODEC_VERSION_MAJOR < 55)
		68	#endif
		69	#ifndef FF_API_INTER_THRESHOLD
		70	#define FF_API_INTER_THRESHOLD (LIBAVCODEC_VERSION_MAJOR < 55)
		71	#endif
63		72
64	#endif /* AVCODEC_VERSION_H */	73	#endif /* AVCODEC_VERSION_H */

libavcodec/vmnc.c+1−1

@@ -484,7 +484,7 @@ static av_cold int decode_init(AVCodecContext *avctx) · 483 unmodified lines
484	break;	484	break;
485	default:	485	default:
486	av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", c->bpp);	486	av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", c->bpp);
487	return AVERROR_PATCHWELCOME;	487	return AVERROR_INVALIDDATA;
488	}	488	}
489		489
490	return 0;	490	return 0;

libavcodec/vp5.c+5−0

         }
         rows = vp56_rac_gets(c, 8);  /* number of stored macroblock rows */
         cols = vp56_rac_gets(c, 8);  /* number of stored macroblock cols */
+        if (!rows || !cols) {
+            av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
+                   cols << 4, rows << 4);
+            return 0;
+        }
         vp56_rac_gets(c, 8);  /* number of displayed macroblock rows */
         vp56_rac_gets(c, 8);  /* number of displayed macroblock cols */
         vp56_rac_gets(c, 2);

libavcodec/vp6.c+5−1

         cols = buf[3];  /* number of stored macroblock cols */
         /* buf[4] is number of displayed macroblock rows */
         /* buf[5] is number of displayed macroblock cols */
+        if (!rows || !cols) {
+            av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n", cols << 4, rows << 4);
+            return 0;
+        }
         if (!s->macroblocks || /* first frame */
             16*cols != s->avctx->coded_width ||
             vrt_shift = 5;
         s->sub_version = sub_version;
     } else {
-        if (!s->sub_version)
+        if (!s->sub_version || !s->avctx->coded_width || !s->avctx->coded_height)
             return 0;
         if (separated_coeff || !s->filter_header) {

libavformat/asfdec.c+5−21

 #include "libavutil/avstring.h"
 #include "libavutil/dict.h"
 #include "libavutil/mathematics.h"
-#include "libavcodec/mpegaudio.h"
 #include "avformat.h"
 #include "internal.h"
 #include "avio_internal.h"
     asf->hdr.flags              = avio_rl32(pb);
     asf->hdr.min_pktsize        = avio_rl32(pb);
     asf->hdr.max_pktsize        = avio_rl32(pb);
+    if (asf->hdr.min_pktsize >= (1U<<29))
+        return AVERROR_INVALIDDATA;
     asf->hdr.max_bitrate        = avio_rl32(pb);
     s->packet_size = asf->hdr.max_pktsize;
                     || asf_st->ds_packet_size % asf_st->ds_chunk_size)
                 asf_st->ds_span = 0; // disable descrambling
         }
-        switch (st->codec->codec_id) {
-            case CODEC_ID_MP3:
-                st->codec->frame_size = MPA_FRAME_SIZE;
-                break;
-            case CODEC_ID_PCM_S16LE:
-            case CODEC_ID_PCM_S16BE:
-            case CODEC_ID_PCM_U16LE:
-            case CODEC_ID_PCM_U16BE:
-            case CODEC_ID_PCM_S8:
-            case CODEC_ID_PCM_U8:
-            case CODEC_ID_PCM_ALAW:
-            case CODEC_ID_PCM_MULAW:
-                st->codec->frame_size = 1;
-                break;
-            default:
-                /* This is probably wrong, but it prevents a crash later */
-                st->codec->frame_size = 1;
-                break;
-        }
     } else if (type == AVMEDIA_TYPE_VIDEO &&
             size - (avio_tell(pb) - pos1 + 24) >= 51) {
         avio_rl32(pb);
         if (gsize < 24)
             return -1;
         if (!ff_guidcmp(&g, &ff_asf_file_header)) {
-            asf_read_file_properties(s, gsize);
+            int ret = asf_read_file_properties(s, gsize);
+            if (ret < 0)
+                return ret;
         } else if (!ff_guidcmp(&g, &ff_asf_stream_header)) {
             asf_read_stream_properties(s, gsize);
         } else if (!ff_guidcmp(&g, &ff_asf_comment_header)) {

libavformat/avformat.h+16−0

@@ -541,6 +541,13 @@ typedef struct AVIndexEntry { · 540 unmodified lines
541	#define AV_DISPOSITION_HEARING_IMPAIRED 0x0080 /*< stream for hearing impaired audiences /	541	#define AV_DISPOSITION_HEARING_IMPAIRED 0x0080 /*< stream for hearing impaired audiences /
542	#define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100 /*< stream for visual impaired audiences /	542	#define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100 /*< stream for visual impaired audiences /
543	#define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /*< stream without voice /	543	#define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /*< stream without voice /
		544	/**
		545	* The stream is stored in the file as an attached picture/"cover art" (e.g.
		546	* APIC frame in ID3v2). The single packet associated with it will be returned
		547	* among the first few packets read from the file unless seeking takes place.
		548	* It can also be accessed at any time in AVStream.attached_pic.
		549	*/
		550	#define AV_DISPOSITION_ATTACHED_PIC 0x0400
544		551
545	/**	552	/**
546	* Stream structure.	553	* Stream structure.
@@ -615,6 +622,15 @@ typedef struct AVStream { · 68 unmodified lines
615	*/	622	*/
616	AVRational avg_frame_rate;	623	AVRational avg_frame_rate;
617		624
		625	/**
		626	* For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet
		627	* will contain the attached picture.
		628	*
		629	* decoding: set by libavformat, must not be modified by the caller.
		630	* encoding: unused
		631	*/
		632	AVPacket attached_pic;
		633
618	/*****************************************************************	634	/*****************************************************************
619	* All fields below this line are not part of the public API. They	635	* All fields below this line are not part of the public API. They
620	* may not be used outside of libavformat and can be changed and	636	* may not be used outside of libavformat and can be changed and

libavformat/dxa.c+2−0

         ret = ff_get_wav_header(pb, ast->codec, fsize);
         if (ret < 0)
             return ret;
+        if (ast->codec->sample_rate > 0)
+            avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
         // find 'data' chunk
         while(avio_tell(pb) < c->vidpos && !url_feof(pb)){
             tag = avio_rl32(pb);

libavformat/ffmdec.c+0−2

             codec->dct_algo = avio_rb32(pb);
             codec->strict_std_compliance = avio_rb32(pb);
             codec->max_b_frames = avio_rb32(pb);
-            codec->luma_elim_threshold = avio_rb32(pb);
-            codec->chroma_elim_threshold = avio_rb32(pb);
             codec->mpeg_quant = avio_rb32(pb);
             codec->intra_dc_precision = avio_rb32(pb);
             codec->me_method = avio_rb32(pb);

libavformat/ffmenc.c+0−2

             avio_wb32(pb, codec->dct_algo);
             avio_wb32(pb, codec->strict_std_compliance);
             avio_wb32(pb, codec->max_b_frames);
-            avio_wb32(pb, codec->luma_elim_threshold);
-            avio_wb32(pb, codec->chroma_elim_threshold);
             avio_wb32(pb, codec->mpeg_quant);
             avio_wb32(pb, codec->intra_dc_precision);
             avio_wb32(pb, codec->me_method);

libavformat/id3v2.c+147−6

@@ -38,6 +38,7 @@ · 37 unmodified lines
38	#include "libavutil/intreadwrite.h"	38	#include "libavutil/intreadwrite.h"
39	#include "libavutil/dict.h"	39	#include "libavutil/dict.h"
40	#include "avio_internal.h"	40	#include "avio_internal.h"
		41	#include "internal.h"
41		42
42	const AVMetadataConv ff_id3v2_34_metadata_conv[] = {	43	const AVMetadataConv ff_id3v2_34_metadata_conv[] = {
43	{ "TALB", "album"},	44	{ "TALB", "album"},
@@ -99,6 +100,38 @@ const char ff_id3v2_3_tags[][4] = { · 55 unmodified lines
99	{ 0 },	100	{ 0 },
100	};	101	};
101		102
		103	const char *ff_id3v2_picture_types[21] = {
		104	"Other",
		105	"32x32 pixels 'file icon'",
		106	"Other file icon",
		107	"Cover (front)",
		108	"Cover (back)",
		109	"Leaflet page",
		110	"Media (e.g. label side of CD)",
		111	"Lead artist/lead performer/soloist",
		112	"Artist/performer",
		113	"Conductor",
		114	"Band/Orchestra",
		115	"Composer",
		116	"Lyricist/text writer",
		117	"Recording Location",
		118	"During recording",
		119	"During performance",
		120	"Movie/video screen capture",
		121	"A bright coloured fish",
		122	"Illustration",
		123	"Band/artist logotype",
		124	"Publisher/Studio logotype",
		125	};
		126
		127	const CodecMime ff_id3v2_mime_tags[] = {
		128	{"image/gif" , CODEC_ID_GIF},
		129	{"image/jpeg", CODEC_ID_MJPEG},
		130	{"image/png" , CODEC_ID_PNG},
		131	{"image/tiff", CODEC_ID_TIFF},
		132	{"", CODEC_ID_NONE},
		133	};
		134
102	int ff_id3v2_match(const uint8_t buf, const char magic)	135	int ff_id3v2_match(const uint8_t buf, const char magic)
103	{	136	{
104	return buf[0] == magic[0] &&	137	return buf[0] == magic[0] &&
@@ -394,6 +427,84 @@ finish: · 289 unmodified lines
394	av_dict_set(m, "date", date, 0);	427	av_dict_set(m, "date", date, 0);
395	}	428	}
396		429
		430	static void free_apic(void *obj)
		431	{
		432	ID3v2ExtraMetaAPIC *apic = obj;
		433	av_freep(&apic->data);
		434	av_freep(&apic->description);
		435	av_freep(&apic);
		436	}
		437
		438	static void read_apic(AVFormatContext s, AVIOContext pb, int taglen, char tag, ID3v2ExtraMeta *extra_meta)
		439	{
		440	int enc, pic_type;
		441	char mimetype[64];
		442	const CodecMime *mime = ff_id3v2_mime_tags;
		443	enum CodecID id = CODEC_ID_NONE;
		444	ID3v2ExtraMetaAPIC *apic = NULL;
		445	ID3v2ExtraMeta *new_extra = NULL;
		446	int64_t end = avio_tell(pb) + taglen;
		447
		448	if (taglen <= 4)
		449	goto fail;
		450
		451	new_extra = av_mallocz(sizeof(*new_extra));
		452	apic = av_mallocz(sizeof(*apic));
		453	if (!new_extra \|\| !apic)
		454	goto fail;
		455
		456	enc = avio_r8(pb);
		457	taglen--;
		458
		459	/* mimetype */
		460	taglen -= avio_get_str(pb, taglen, mimetype, sizeof(mimetype));
		461	while (mime->id != CODEC_ID_NONE) {
		462	if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
		463	id = mime->id;
		464	break;
		465	}
		466	mime++;
		467	}
		468	if (id == CODEC_ID_NONE) {
		469	av_log(s, AV_LOG_WARNING, "Unknown attached picture mimetype: %s, skipping.\n", mimetype);
		470	goto fail;
		471	}
		472	apic->id = id;
		473
		474	/* picture type */
		475	pic_type = avio_r8(pb);
		476	taglen--;
		477	if (pic_type < 0 \|\| pic_type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types)) {
		478	av_log(s, AV_LOG_WARNING, "Unknown attached picture type %d.\n", pic_type);
		479	pic_type = 0;
		480	}
		481	apic->type = ff_id3v2_picture_types[pic_type];
		482
		483	/* description and picture data */
		484	if (decode_str(s, pb, enc, &apic->description, &taglen) < 0) {
		485	av_log(s, AV_LOG_ERROR, "Error decoding attached picture description.\n");
		486	goto fail;
		487	}
		488
		489	apic->len = taglen;
		490	apic->data = av_malloc(taglen);
		491	if (!apic->data \|\| avio_read(pb, apic->data, taglen) != taglen)
		492	goto fail;
		493
		494	new_extra->tag = "APIC";
		495	new_extra->data = apic;
		496	new_extra->next = *extra_meta;
		497	*extra_meta = new_extra;
		498
		499	return;
		500
		501	fail:
		502	if (apic)
		503	free_apic(apic);
		504	av_freep(&new_extra);
		505	avio_seek(pb, end, SEEK_SET);
		506	}
		507
397	typedef struct ID3v2EMFunc {	508	typedef struct ID3v2EMFunc {
398	const char *tag3;	509	const char *tag3;
399	const char *tag4;	510	const char *tag4;
@@ -403,6 +514,7 @@ typedef struct ID3v2EMFunc { · 3 unmodified lines
403		514
404	static const ID3v2EMFunc id3v2_extra_meta_funcs[] = {	515	static const ID3v2EMFunc id3v2_extra_meta_funcs[] = {
405	{ "GEO", "GEOB", read_geobtag, free_geobtag },	516	{ "GEO", "GEOB", read_geobtag, free_geobtag },
		517	{ "PIC", "APIC", read_apic, free_apic },
406	{ NULL }	518	{ NULL }
407	};	519	};
408		520
@@ -620,7 +732,7 @@ seek: · 211 unmodified lines
620	return;	732	return;
621	}	733	}
622		734
623	void ff_id3v2_read_all(AVFormatContext s, const char magic, ID3v2ExtraMeta **extra_meta)	735	void ff_id3v2_read(AVFormatContext s, const char magic, ID3v2ExtraMeta **extra_meta)
624	{	736	{
625	int len, ret;	737	int len, ret;
626	uint8_t buf[ID3v2_HEADER_SIZE];	738	uint8_t buf[ID3v2_HEADER_SIZE];
@@ -651,11 +763,6 @@ void ff_id3v2_read_all(AVFormatContext s, const char magic, ID3v2ExtraMeta **e · 24 unmodified lines
651	merge_date(&s->metadata);	763	merge_date(&s->metadata);
652	}	764	}
653		765
654	void ff_id3v2_read(AVFormatContext s, const char magic)
655	{
656	ff_id3v2_read_all(s, magic, NULL);
657	}
658
659	void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)	766	void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
660	{	767	{
661	ID3v2ExtraMeta current = extra_meta, *next;	768	ID3v2ExtraMeta current = extra_meta, *next;
@@ -669,3 +776,37 @@ void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta) · 7 unmodified lines
669	current = next;	776	current = next;
670	}	777	}
671	}	778	}
		779
		780	int ff_id3v2_parse_apic(AVFormatContext s, ID3v2ExtraMeta *extra_meta)
		781	{
		782	ID3v2ExtraMeta *cur;
		783
		784	for (cur = *extra_meta; cur; cur = cur->next) {
		785	ID3v2ExtraMetaAPIC *apic;
		786	AVStream *st;
		787
		788	if (strcmp(cur->tag, "APIC"))
		789	continue;
		790	apic = cur->data;
		791
		792	if (!(st = avformat_new_stream(s, NULL)))
		793	return AVERROR(ENOMEM);
		794
		795	st->disposition \|= AV_DISPOSITION_ATTACHED_PIC;
		796	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
		797	st->codec->codec_id = apic->id;
		798	av_dict_set(&st->metadata, "title", apic->description, 0);
		799	av_dict_set(&st->metadata, "comment", apic->type, 0);
		800
		801	av_init_packet(&st->attached_pic);
		802	st->attached_pic.data = apic->data;
		803	st->attached_pic.size = apic->len;
		804	st->attached_pic.destruct = av_destruct_packet;
		805	st->attached_pic.stream_index = st->index;
		806
		807	apic->data = NULL;
		808	apic->len = 0;
		809	}
		810
		811	return 0;
		812	}

libavformat/id3v2.h+49−8

 #include <stdint.h>
 #include "avformat.h"
+#include "internal.h"
 #include "metadata.h"
 #define ID3v2_HEADER_SIZE 10
     ID3v2_ENCODING_UTF8     = 3,
 };
+typedef struct ID3v2EncContext {
+    int      version;       ///< ID3v2 minor version, either 3 or 4
+    int64_t size_pos;       ///< offset of the tag total size
+    int          len;       ///< size of the tag written so far
+} ID3v2EncContext;
 typedef struct ID3v2ExtraMeta {
     const char *tag;
     void *data;
     uint8_t *data;
 } ID3v2ExtraMetaGEOB;
+typedef struct ID3v2ExtraMetaAPIC {
+    uint8_t     *data;
+    int          len;
+    const char  *type;
+    uint8_t     *description;
+    enum CodecID id;
+} ID3v2ExtraMetaAPIC;
 /**
  * Detect ID3v2 Header.
  * @param buf   must be ID3v2_HEADER_SIZE byte long
 int ff_id3v2_tag_len(const uint8_t *buf);
 /**
- * Read an ID3v2 tag (text tags only)
+ * Read an ID3v2 tag, including supported extra metadata
+ * @param extra_meta If not NULL, extra metadata is parsed into a list of
+ * ID3v2ExtraMeta structs and *extra_meta points to the head of the list
  */
-void ff_id3v2_read(AVFormatContext *s, const char *magic);
+void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta);
 /**
- * Read an ID3v2 tag, including supported extra metadata (currently only GEOB)
+ * Initialize an ID3v2 tag.
- * @param extra_meta If not NULL, extra metadata is parsed into a list of
+ */
- * ID3v2ExtraMeta structs and *extra_meta points to the head of the list
+void ff_id3v2_start(ID3v2EncContext *id3, AVIOContext *pb, int id3v2_version,
+                    const char *magic);
+/**
+ * Convert and write all global metadata from s into an ID3v2 tag.
+ */
+int ff_id3v2_write_metadata(AVFormatContext *s, ID3v2EncContext *id3);
+/**
+ * Write an attached picture from pkt into an ID3v2 tag.
+ */
+int ff_id3v2_write_apic(AVFormatContext *s, ID3v2EncContext *id3, AVPacket *pkt);
+/**
+ * Finalize an opened ID3v2 tag.
  */
-void ff_id3v2_read_all(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta);
+void ff_id3v2_finish(ID3v2EncContext *id3, AVIOContext *pb);
 /**
- * Write an ID3v2 tag.
+ * Write an ID3v2 tag containing all global metadata from s.
  * @param id3v2_version Subversion of ID3v2; supported values are 3 and 4
  * @param magic magic bytes to identify the header
  * If in doubt, use ID3v2_DEFAULT_MAGIC.
  */
-int ff_id3v2_write(struct AVFormatContext *s, int id3v2_version, const char *magic);
+int ff_id3v2_write_simple(struct AVFormatContext *s, int id3v2_version, const char *magic);
 /**
  * Free memory allocated parsing special (non-text) metadata.
  */
 void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta);
+/**
+ * Create a stream for each APIC (attached picture) extracted from the
+ * ID3v2 header.
+ */
+int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta);
 extern const AVMetadataConv ff_id3v2_34_metadata_conv[];
 extern const AVMetadataConv ff_id3v2_4_metadata_conv[];
  */
 extern const char ff_id3v2_3_tags[][4];
+extern const CodecMime ff_id3v2_mime_tags[];
+extern const char *ff_id3v2_picture_types[21];
 #endif /* AVFORMAT_ID3V2_H */

libavformat/id3v2enc.c+145−47

@@ -19,6 +19,8 @@ · 18 unmodified lines
19	*/	19	*/
20		20
21	#include <stdint.h>	21	#include <stdint.h>
		22	#include <string.h>
		23
22	#include "libavutil/avstring.h"	24	#include "libavutil/avstring.h"
23	#include "libavutil/dict.h"	25	#include "libavutil/dict.h"
24	#include "libavutil/intreadwrite.h"	26	#include "libavutil/intreadwrite.h"
@@ -26,12 +28,12 @@ · 1 unmodified line
26	#include "avio.h"	28	#include "avio.h"
27	#include "id3v2.h"	29	#include "id3v2.h"
28		30
29	static void id3v2_put_size(AVFormatContext *s, int size)	31	static void id3v2_put_size(AVIOContext *pb, int size)
30	{	32	{
31	avio_w8(s->pb, size >> 21 & 0x7f);	33	avio_w8(pb, size >> 21 & 0x7f);
32	avio_w8(s->pb, size >> 14 & 0x7f);	34	avio_w8(pb, size >> 14 & 0x7f);
33	avio_w8(s->pb, size >> 7 & 0x7f);	35	avio_w8(pb, size >> 7 & 0x7f);
34	avio_w8(s->pb, size & 0x7f);	36	avio_w8(pb, size & 0x7f);
35	}	37	}
36		38
37	static int string_is_ascii(const uint8_t *str)	39	static int string_is_ascii(const uint8_t *str)
@@ -40,17 +42,30 @@ static int string_is_ascii(const uint8_t *str) · 2 unmodified lines
40	return !*str;	42	return !*str;
41	}	43	}
42		44
		45	static void id3v2_encode_string(AVIOContext pb, const uint8_t str,
		46	enum ID3v2Encoding enc)
		47	{
		48	int (put)(AVIOContext, const char*);
		49
		50	if (enc == ID3v2_ENCODING_UTF16BOM) {
		51	avio_wl16(pb, 0xFEFF); /* BOM */
		52	put = avio_put_str16le;
		53	} else
		54	put = avio_put_str;
		55
		56	put(pb, str);
		57	}
		58
43	/**	59	/**
44	* Write a text frame with one (normal frames) or two (TXXX frames) strings	60	* Write a text frame with one (normal frames) or two (TXXX frames) strings
45	* according to encoding (only UTF-8 or UTF-16+BOM supported).	61	* according to encoding (only UTF-8 or UTF-16+BOM supported).
46	* @return number of bytes written or a negative error code.	62	* @return number of bytes written or a negative error code.
47	*/	63	*/
48	static int id3v2_put_ttag(AVFormatContext s, const char str1, const char *str2,	64	static int id3v2_put_ttag(ID3v2EncContext id3, AVIOContext avioc, const char str1, const char str2,
49	uint32_t tag, enum ID3v2Encoding enc)	65	uint32_t tag, enum ID3v2Encoding enc)
50	{	66	{
51	int len;	67	int len;
52	uint8_t *pb;	68	uint8_t *pb;
53	int (put)(AVIOContext, const char*);
54	AVIOContext *dyn_buf;	69	AVIOContext *dyn_buf;
55	if (avio_open_dyn_buf(&dyn_buf) < 0)	70	if (avio_open_dyn_buf(&dyn_buf) < 0)
56	return AVERROR(ENOMEM);	71	return AVERROR(ENOMEM);
@@ -62,28 +77,26 @@ static int id3v2_put_ttag(AVFormatContext s, const char str1, const char *str2 · 5 unmodified lines
62	enc = ID3v2_ENCODING_ISO8859;	77	enc = ID3v2_ENCODING_ISO8859;
63		78
64	avio_w8(dyn_buf, enc);	79	avio_w8(dyn_buf, enc);
65	if (enc == ID3v2_ENCODING_UTF16BOM) {	80	id3v2_encode_string(dyn_buf, str1, enc);
66	avio_wl16(dyn_buf, 0xFEFF); /* BOM */
67	put = avio_put_str16le;
68	} else
69	put = avio_put_str;
70
71	put(dyn_buf, str1);
72	if (str2)	81	if (str2)
73	put(dyn_buf, str2);	82	id3v2_encode_string(dyn_buf, str2, enc);
74	len = avio_close_dyn_buf(dyn_buf, &pb);	83	len = avio_close_dyn_buf(dyn_buf, &pb);
75		84
76	avio_wb32(s->pb, tag);	85	avio_wb32(avioc, tag);
77	id3v2_put_size(s, len);	86	/* ID3v2.3 frame size is not synchsafe */
78	avio_wb16(s->pb, 0);	87	if (id3->version == 3)
79	avio_write(s->pb, pb, len);	88	avio_wb32(avioc, len);
		89	else
		90	id3v2_put_size(avioc, len);
		91	avio_wb16(avioc, 0);
		92	avio_write(avioc, pb, len);
80		93
81	av_freep(&pb);	94	av_freep(&pb);
82	return len + ID3v2_HEADER_SIZE;	95	return len + ID3v2_HEADER_SIZE;
83	}	96	}
84		97
85	static int id3v2_check_write_tag(AVFormatContext s, AVDictionaryEntry t, const char table[][4],	98	static int id3v2_check_write_tag(ID3v2EncContext id3, AVIOContext pb, AVDictionaryEntry *t,
86	enum ID3v2Encoding enc)	99	const char table[][4], enum ID3v2Encoding enc)
87	{	100	{
88	uint32_t tag;	101	uint32_t tag;
89	int i;	102	int i;
@@ -93,7 +106,7 @@ static int id3v2_check_write_tag(AVFormatContext s, AVDictionaryEntry t, const · 3 unmodified lines
93	tag = AV_RB32(t->key);	106	tag = AV_RB32(t->key);
94	for (i = 0; *table[i]; i++)	107	for (i = 0; *table[i]; i++)
95	if (tag == AV_RB32(table[i]))	108	if (tag == AV_RB32(table[i]))
96	return id3v2_put_ttag(s, t->value, NULL, tag, enc);	109	return id3v2_put_ttag(id3, pb, t->value, NULL, tag, enc);
97	return -1;	110	return -1;
98	}	111	}
99		112
@@ -135,52 +148,137 @@ static void id3v2_3_metadata_split_date(AVDictionary **pm) · 35 unmodified lines
135	*pm = dst;	148	*pm = dst;
136	}	149	}
137		150
138	int ff_id3v2_write(struct AVFormatContext *s, int id3v2_version,	151	void ff_id3v2_start(ID3v2EncContext id3, AVIOContext pb, int id3v2_version,
139	const char *magic)	152	const char *magic)
140	{	153	{
141	int64_t size_pos, cur_pos;	154	id3->version = id3v2_version;
142	AVDictionaryEntry *t = NULL;
143		155
144	int totlen = 0, enc = id3v2_version == 3 ? ID3v2_ENCODING_UTF16BOM :	156	avio_wb32(pb, MKBETAG(magic[0], magic[1], magic[2], id3v2_version));
145	ID3v2_ENCODING_UTF8;	157	avio_w8(pb, 0);
146		158	avio_w8(pb, 0); /* flags */
147
148	avio_wb32(s->pb, MKBETAG(magic[0], magic[1], magic[2], id3v2_version));
149	avio_w8(s->pb, 0);
150	avio_w8(s->pb, 0); /* flags */
151		159
152	/* reserve space for size */	160	/* reserve space for size */
153	size_pos = avio_tell(s->pb);	161	id3->size_pos = avio_tell(pb);
154	avio_wb32(s->pb, 0);	162	avio_wb32(pb, 0);
		163	}
		164
		165	int ff_id3v2_write_metadata(AVFormatContext s, ID3v2EncContext id3)
		166	{
		167	AVDictionaryEntry *t = NULL;
		168	int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :
		169	ID3v2_ENCODING_UTF8;
155		170
156	ff_metadata_conv(&s->metadata, ff_id3v2_34_metadata_conv, NULL);	171	ff_metadata_conv(&s->metadata, ff_id3v2_34_metadata_conv, NULL);
157	if (id3v2_version == 3)	172	if (id3->version == 3)
158	id3v2_3_metadata_split_date(&s->metadata);	173	id3v2_3_metadata_split_date(&s->metadata);
159	else if (id3v2_version == 4)	174	else if (id3->version == 4)
160	ff_metadata_conv(&s->metadata, ff_id3v2_4_metadata_conv, NULL);	175	ff_metadata_conv(&s->metadata, ff_id3v2_4_metadata_conv, NULL);
161		176
162	while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) {	177	while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) {
163	int ret;	178	int ret;
164		179
165	if ((ret = id3v2_check_write_tag(s, t, ff_id3v2_tags, enc)) > 0) {	180	if ((ret = id3v2_check_write_tag(id3, s->pb, t, ff_id3v2_tags, enc)) > 0) {
166	totlen += ret;	181	id3->len += ret;
167	continue;	182	continue;
168	}	183	}
169	if ((ret = id3v2_check_write_tag(s, t, id3v2_version == 3 ?	184	if ((ret = id3v2_check_write_tag(id3, s->pb, t, id3->version == 3 ?
170	ff_id3v2_3_tags : ff_id3v2_4_tags, enc)) > 0) {	185	ff_id3v2_3_tags : ff_id3v2_4_tags, enc)) > 0) {
171	totlen += ret;	186	id3->len += ret;
172	continue;	187	continue;
173	}	188	}
174		189
175	/* unknown tag, write as TXXX frame */	190	/* unknown tag, write as TXXX frame */
176	if ((ret = id3v2_put_ttag(s, t->key, t->value, MKBETAG('T', 'X', 'X', 'X'), enc)) < 0)	191	if ((ret = id3v2_put_ttag(id3, s->pb, t->key, t->value, MKBETAG('T', 'X', 'X', 'X'), enc)) < 0)
177	return ret;	192	return ret;
178	totlen += ret;	193	id3->len += ret;
179	}	194	}
180		195
181	cur_pos = avio_tell(s->pb);	196	return 0;
182	avio_seek(s->pb, size_pos, SEEK_SET);	197	}
183	id3v2_put_size(s, totlen);	198
184	avio_seek(s->pb, cur_pos, SEEK_SET);	199	int ff_id3v2_write_apic(AVFormatContext s, ID3v2EncContext id3, AVPacket *pkt)
		200	{
		201	AVStream *st = s->streams[pkt->stream_index];
		202	AVDictionaryEntry *e;
		203
		204	AVIOContext *dyn_buf;
		205	uint8_t *buf;
		206	const CodecMime *mime = ff_id3v2_mime_tags;
		207	const char mimetype = NULL, desc = "";
		208	int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :
		209	ID3v2_ENCODING_UTF8;
		210	int i, len, type = 0;
		211
		212	/* get the mimetype*/
		213	while (mime->id != CODEC_ID_NONE) {
		214	if (mime->id == st->codec->codec_id) {
		215	mimetype = mime->str;
		216	break;
		217	}
		218	mime++;
		219	}
		220	if (!mimetype) {
		221	av_log(s, AV_LOG_ERROR, "No mimetype is known for stream %d, cannot "
		222	"write an attached picture.\n", st->index);
		223	return AVERROR(EINVAL);
		224	}
		225
		226	/* get the picture type */
		227	e = av_dict_get(st->metadata, "comment", NULL, 0);
		228	for (i = 0; e && i < FF_ARRAY_ELEMS(ff_id3v2_picture_types); i++) {
		229	if (strstr(ff_id3v2_picture_types[i], e->value) == ff_id3v2_picture_types[i]) {
		230	type = i;
		231	break;
		232	}
		233	}
		234
		235	/* get the description */
		236	if ((e = av_dict_get(st->metadata, "title", NULL, 0)))
		237	desc = e->value;
		238
		239	/* start writing */
		240	if (avio_open_dyn_buf(&dyn_buf) < 0)
		241	return AVERROR(ENOMEM);
		242
		243	avio_w8(dyn_buf, enc);
		244	avio_put_str(dyn_buf, mimetype);
		245	avio_w8(dyn_buf, type);
		246	id3v2_encode_string(dyn_buf, desc, enc);
		247	avio_write(dyn_buf, pkt->data, pkt->size);
		248	len = avio_close_dyn_buf(dyn_buf, &buf);
		249
		250	avio_wb32(s->pb, MKBETAG('A', 'P', 'I', 'C'));
		251	if (id3->version == 3)
		252	avio_wb32(s->pb, len);
		253	else
		254	id3v2_put_size(s->pb, len);
		255	avio_wb16(s->pb, 0);
		256	avio_write(s->pb, buf, len);
		257	av_freep(&buf);
		258
		259	id3->len += len + ID3v2_HEADER_SIZE;
		260
		261	return 0;
		262	}
		263
		264	void ff_id3v2_finish(ID3v2EncContext id3, AVIOContext pb)
		265	{
		266	int64_t cur_pos = avio_tell(pb);
		267	avio_seek(pb, id3->size_pos, SEEK_SET);
		268	id3v2_put_size(pb, id3->len);
		269	avio_seek(pb, cur_pos, SEEK_SET);
		270	}
		271
		272	int ff_id3v2_write_simple(struct AVFormatContext *s, int id3v2_version,
		273	const char *magic)
		274	{
		275	ID3v2EncContext id3 = { 0 };
		276	int ret;
		277
		278	ff_id3v2_start(&id3, s->pb, id3v2_version, magic);
		279	if ((ret = ff_id3v2_write_metadata(s, &id3)) < 0)
		280	return ret;
		281	ff_id3v2_finish(&id3, s->pb);
		282
185	return 0;	283	return 0;
186	}	284	}

libavformat/internal.h+5−0

     unsigned int tag;
 } AVCodecTag;
+typedef struct CodecMime{
+    char str[32];
+    enum CodecID id;
+} CodecMime;
 #ifdef __GNUC__
 #define dynarray_add(tab, nb_ptr, elem)\
 do {\

libavformat/matroska.h+1−5

 #include "libavcodec/avcodec.h"
 #include "metadata.h"
+#include "internal.h"
 /* EBML version supported */
 #define EBML_VERSION 1
     enum CodecID id;
 }CodecTags;
-typedef struct CodecMime{
-    char str[32];
-    enum CodecID id;
-}CodecMime;
 /* max. depth in the EBML tree structure */
 #define EBML_MAX_DEPTH 16

libavformat/mov.c+4−3

         if (st->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
             unsigned int color_depth, len;
             int color_greyscale;
+            int color_table_id;
             st->codec->codec_id = id;
             avio_rb16(pb); /* version */
                 st->codec->codec_tag=MKTAG('I', '4', '2', '0');
             st->codec->bits_per_coded_sample = avio_rb16(pb); /* depth */
-            st->codec->color_table_id = avio_rb16(pb); /* colortable id */
+            color_table_id = avio_rb16(pb); /* colortable id */
             av_dlog(c->fc, "depth %d, ctab id %d\n",
-                   st->codec->bits_per_coded_sample, st->codec->color_table_id);
+                   st->codec->bits_per_coded_sample, color_table_id);
             /* figure out the palette situation */
             color_depth = st->codec->bits_per_coded_sample & 0x1F;
             color_greyscale = st->codec->bits_per_coded_sample & 0x20;
                         if (color_index < 0)
                             color_index = 0;
                     }
-                } else if (st->codec->color_table_id) {
+                } else if (color_table_id) {
                     const uint8_t *color_table;
                     /* if flag bit 3 is set, use the default palette */
                     color_count = 1 << color_depth;

libavformat/mp3enc.c+183−74

@@ -84,6 +84,7 @@ static int id3v1_create_tag(AVFormatContext s, uint8_t buf) · 83 unmodified lines
84		84
85	typedef struct MP3Context {	85	typedef struct MP3Context {
86	const AVClass *class;	86	const AVClass *class;
		87	ID3v2EncContext id3;
87	int id3v2_version;	88	int id3v2_version;
88	int write_id3v1;	89	int write_id3v1;
89	int64_t frames_offset;	90	int64_t frames_offset;
@@ -93,60 +94,15 @@ typedef struct MP3Context { · 3 unmodified lines
93	uint32_t seen;	94	uint32_t seen;
94	uint32_t pos;	95	uint32_t pos;
95	uint64_t bag[VBR_NUM_BAGS];	96	uint64_t bag[VBR_NUM_BAGS];
96	} MP3Context;
97
98	static int mp2_write_trailer(struct AVFormatContext *s)
99	{
100	uint8_t buf[ID3v1_TAG_SIZE];
101	MP3Context *mp3 = s->priv_data;
102
103	/* write the id3v1 tag */
104	if (mp3 && mp3->write_id3v1 && id3v1_create_tag(s, buf) > 0) {
105	avio_write(s->pb, buf, ID3v1_TAG_SIZE);
106	}
107		97
108	/* write number of frames */	98	/* index of the audio stream */
109	if (mp3 && mp3->frames_offset) {	99	int audio_stream_idx;
110	avio_seek(s->pb, mp3->frames_offset, SEEK_SET);	100	/* number of attached pictures we still need to write */
111	avio_wb32(s->pb, s->streams[0]->nb_frames);	101	int pics_to_write;
112	avio_seek(s->pb, 0, SEEK_END);
113	}
114
115	avio_flush(s->pb);
116
117	return 0;
118	}
119
120	#if CONFIG_MP2_MUXER
121	AVOutputFormat ff_mp2_muxer = {
122	.name = "mp2",
123	.long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
124	.mime_type = "audio/x-mpeg",
125	.extensions = "mp2,m2a",
126	.audio_codec = CODEC_ID_MP2,
127	.video_codec = CODEC_ID_NONE,
128	.write_packet = ff_raw_write_packet,
129	.write_trailer = mp2_write_trailer,
130	.flags = AVFMT_NOTIMESTAMPS,
131	};
132	#endif
133
134	#if CONFIG_MP3_MUXER
135
136	static const AVOption options[] = {
137	{ "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
138	offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.dbl = 4}, 3, 4, AV_OPT_FLAG_ENCODING_PARAM},
139	{ "write_id3v1", "Enable ID3v1 writing. ID3v1 tags are written in UTF-8 which may not be supported by most software.",
140	offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
141	{ NULL },
142	};
143		102
144	static const AVClass mp3_muxer_class = {	103	/* audio packets are queued here until we get all the attached pictures */
145	.class_name = "MP3 muxer",	104	AVPacketList queue, queue_end;
146	.item_name = av_default_item_name,	105	} MP3Context;
147	.option = options,
148	.version = LIBAVUTIL_VERSION_INT,
149	};
150		106
151	static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};	107	static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
152		108
@@ -155,8 +111,8 @@ static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}}; · 2 unmodified lines
155	*/	111	*/
156	static int mp3_write_xing(AVFormatContext *s)	112	static int mp3_write_xing(AVFormatContext *s)
157	{	113	{
158	AVCodecContext *codec = s->streams[0]->codec;
159	MP3Context *mp3 = s->priv_data;	114	MP3Context *mp3 = s->priv_data;
		115	AVCodecContext *codec = s->streams[mp3->audio_stream_idx]->codec;
160	int bitrate_idx;	116	int bitrate_idx;
161	int best_bitrate_idx = -1;	117	int best_bitrate_idx = -1;
162	int best_bitrate_error= INT_MAX;	118	int best_bitrate_error= INT_MAX;
@@ -166,6 +122,9 @@ static int mp3_write_xing(AVFormatContext *s) · 3 unmodified lines
166	int srate_idx, i, channels;	122	int srate_idx, i, channels;
167	int needed;	123	int needed;
168		124
		125	if (!s->pb->seekable)
		126	return 0;
		127
169	for (i = 0; i < FF_ARRAY_ELEMS(avpriv_mpa_freq_tab); i++)	128	for (i = 0; i < FF_ARRAY_ELEMS(avpriv_mpa_freq_tab); i++)
170	if (avpriv_mpa_freq_tab[i] == codec->sample_rate) {	129	if (avpriv_mpa_freq_tab[i] == codec->sample_rate) {
171	srate_idx = i;	130	srate_idx = i;
@@ -295,26 +254,7 @@ static void mp3_fix_xing(AVFormatContext *s) · 123 unmodified lines
295	avio_seek(s->pb, 0, SEEK_END);	254	avio_seek(s->pb, 0, SEEK_END);
296	}	255	}
297		256
298	/**	257	static int mp3_write_packet_internal(AVFormatContext s, AVPacket pkt)
299	* Write an ID3v2 header at beginning of stream
300	*/
301
302	static int mp3_write_header(struct AVFormatContext *s)
303	{
304	MP3Context *mp3 = s->priv_data;
305	int ret;
306
307	ret = ff_id3v2_write(s, mp3->id3v2_version, ID3v2_DEFAULT_MAGIC);
308	if (ret < 0)
309	return ret;
310
311	if (s->pb->seekable)
312	mp3_write_xing(s);
313
314	return 0;
315	}
316
317	static int mp3_write_packet(AVFormatContext s, AVPacket pkt)
318	{	258	{
319	if (! pkt \|\| ! pkt->data \|\| pkt->size < 4)	259	if (! pkt \|\| ! pkt->data \|\| pkt->size < 4)
320	return ff_raw_write_packet(s, pkt);	260	return ff_raw_write_packet(s, pkt);
@@ -350,6 +290,175 @@ static int mp3_write_packet(AVFormatContext s, AVPacket pkt) · 29 unmodified lines
350	}	290	}
351	}	291	}
352		292
		293	static int mp3_queue_flush(AVFormatContext *s)
		294	{
		295	MP3Context *mp3 = s->priv_data;
		296	AVPacketList *pktl;
		297	int ret = 0, write = 1;
		298
		299	ff_id3v2_finish(&mp3->id3, s->pb);
		300	mp3_write_xing(s);
		301
		302	while ((pktl = mp3->queue)) {
		303	if (write && (ret = mp3_write_packet_internal(s, &pktl->pkt)) < 0)
		304	write = 0;
		305	av_free_packet(&pktl->pkt);
		306	mp3->queue = pktl->next;
		307	av_freep(&pktl);
		308	}
		309	mp3->queue_end = NULL;
		310	return ret;
		311	}
		312
		313	static int mp2_write_trailer(struct AVFormatContext *s)
		314	{
		315	uint8_t buf[ID3v1_TAG_SIZE];
		316	MP3Context *mp3 = s->priv_data;
		317
		318	if (mp3 && mp3->pics_to_write) {
		319	av_log(s, AV_LOG_WARNING, "No packets were sent for some of the "
		320	"attached pictures.\n");
		321	mp3_queue_flush(s);
		322	}
		323
		324	/* write the id3v1 tag */
		325	if (mp3 && mp3->write_id3v1 && id3v1_create_tag(s, buf) > 0) {
		326	avio_write(s->pb, buf, ID3v1_TAG_SIZE);
		327	}
		328
		329	/* write number of frames */
		330	if (mp3 && mp3->frames_offset) {
		331	avio_seek(s->pb, mp3->frames_offset, SEEK_SET);
		332	avio_wb32(s->pb, s->streams[mp3->audio_stream_idx]->nb_frames);
		333	avio_seek(s->pb, 0, SEEK_END);
		334	}
		335
		336	avio_flush(s->pb);
		337
		338	return 0;
		339	}
		340
		341	#if CONFIG_MP2_MUXER
		342	AVOutputFormat ff_mp2_muxer = {
		343	.name = "mp2",
		344	.long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
		345	.mime_type = "audio/x-mpeg",
		346	.extensions = "mp2,m2a",
		347	.audio_codec = CODEC_ID_MP2,
		348	.video_codec = CODEC_ID_NONE,
		349	.write_packet = ff_raw_write_packet,
		350	.write_trailer = mp2_write_trailer,
		351	.flags = AVFMT_NOTIMESTAMPS,
		352	};
		353	#endif
		354
		355	#if CONFIG_MP3_MUXER
		356
		357	static const AVOption options[] = {
		358	{ "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
		359	offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.dbl = 4}, 3, 4, AV_OPT_FLAG_ENCODING_PARAM},
		360	{ "write_id3v1", "Enable ID3v1 writing. ID3v1 tags are written in UTF-8 which may not be supported by most software.",
		361	offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
		362	{ NULL },
		363	};
		364
		365	static const AVClass mp3_muxer_class = {
		366	.class_name = "MP3 muxer",
		367	.item_name = av_default_item_name,
		368	.option = options,
		369	.version = LIBAVUTIL_VERSION_INT,
		370	};
		371
		372	static int mp3_write_packet(AVFormatContext s, AVPacket pkt)
		373	{
		374	MP3Context *mp3 = s->priv_data;
		375
		376	if (pkt->stream_index == mp3->audio_stream_idx) {
		377	if (mp3->pics_to_write) {
		378	/* buffer audio packets until we get all the pictures */
		379	AVPacketList pktl = av_mallocz(sizeof(pktl));
		380	if (!pktl)
		381	return AVERROR(ENOMEM);
		382
		383	pktl->pkt = *pkt;
		384	pkt->destruct = NULL;
		385
		386	if (mp3->queue_end)
		387	mp3->queue_end->next = pktl;
		388	else
		389	mp3->queue = pktl;
		390	mp3->queue_end = pktl;
		391	} else
		392	return mp3_write_packet_internal(s, pkt);
		393	} else {
		394	int ret;
		395
		396	/* warn only once for each stream */
		397	if (s->streams[pkt->stream_index]->nb_frames == 1) {
		398	av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
		399	" ignoring.\n", pkt->stream_index);
		400	}
		401	if (!mp3->pics_to_write \|\| s->streams[pkt->stream_index]->nb_frames >= 1)
		402	return 0;
		403
		404	if ((ret = ff_id3v2_write_apic(s, &mp3->id3, pkt)) < 0)
		405	return ret;
		406	mp3->pics_to_write--;
		407
		408	/* flush the buffered audio packets */
		409	if (!mp3->pics_to_write &&
		410	(ret = mp3_queue_flush(s)) < 0)
		411	return ret;
		412	}
		413
		414	return 0;
		415	}
		416
		417	/**
		418	* Write an ID3v2 header at beginning of stream
		419	*/
		420
		421	static int mp3_write_header(struct AVFormatContext *s)
		422	{
		423	MP3Context *mp3 = s->priv_data;
		424	int ret, i;
		425
		426	/* check the streams -- we want exactly one audio and arbitrary number of
		427	* video (attached pictures) */
		428	mp3->audio_stream_idx = -1;
		429	for (i = 0; i < s->nb_streams; i++) {
		430	AVStream *st = s->streams[i];
		431	if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
		432	if (mp3->audio_stream_idx >= 0 \|\| st->codec->codec_id != CODEC_ID_MP3) {
		433	av_log(s, AV_LOG_ERROR, "Invalid audio stream. Exactly one MP3 "
		434	"audio stream is required.\n");
		435	return AVERROR(EINVAL);
		436	}
		437	mp3->audio_stream_idx = i;
		438	} else if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO) {
		439	av_log(s, AV_LOG_ERROR, "Only audio streams and pictures are allowed in MP3.\n");
		440	return AVERROR(EINVAL);
		441	}
		442	}
		443	if (mp3->audio_stream_idx < 0) {
		444	av_log(s, AV_LOG_ERROR, "No audio stream present.\n");
		445	return AVERROR(EINVAL);
		446	}
		447	mp3->pics_to_write = s->nb_streams - 1;
		448
		449	ff_id3v2_start(&mp3->id3, s->pb, mp3->id3v2_version, ID3v2_DEFAULT_MAGIC);
		450	ret = ff_id3v2_write_metadata(s, &mp3->id3);
		451	if (ret < 0)
		452	return ret;
		453
		454	if (!mp3->pics_to_write) {
		455	ff_id3v2_finish(&mp3->id3, s->pb);
		456	mp3_write_xing(s);
		457	}
		458
		459	return 0;
		460	}
		461
353	static int mp3_write_trailer(AVFormatContext *s)	462	static int mp3_write_trailer(AVFormatContext *s)
354	{	463	{
355	MP3Context *mp3 = s->priv_data;	464	MP3Context *mp3 = s->priv_data;
@@ -371,7 +480,7 @@ AVOutputFormat ff_mp3_muxer = { · 15 unmodified lines
371	.extensions = "mp3",	480	.extensions = "mp3",
372	.priv_data_size = sizeof(MP3Context),	481	.priv_data_size = sizeof(MP3Context),
373	.audio_codec = CODEC_ID_MP3,	482	.audio_codec = CODEC_ID_MP3,
374	.video_codec = CODEC_ID_NONE,	483	.video_codec = CODEC_ID_PNG,
375	.write_header = mp3_write_header,	484	.write_header = mp3_write_header,
376	.write_packet = mp3_write_packet,	485	.write_packet = mp3_write_packet,
377	.write_trailer = mp3_write_trailer,	486	.write_trailer = mp3_write_trailer,

libavformat/omadec.c+1−1

@@ -270,7 +270,7 @@ static int oma_read_header(AVFormatContext *s) · 269 unmodified lines
270	ID3v2ExtraMeta *extra_meta = NULL;	270	ID3v2ExtraMeta *extra_meta = NULL;
271	OMAContext *oc = s->priv_data;	271	OMAContext *oc = s->priv_data;
272		272
273	ff_id3v2_read_all(s, ID3v2_EA3_MAGIC, &extra_meta);	273	ff_id3v2_read(s, ID3v2_EA3_MAGIC, &extra_meta);
274	ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);	274	ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);
275	if (ret < EA3_HEADER_SIZE)	275	if (ret < EA3_HEADER_SIZE)
276	return -1;	276	return -1;

libavformat/omaenc.c+1−1

@@ -49,7 +49,7 @@ static av_cold int oma_write_header(AVFormatContext *s) · 48 unmodified lines
49	}	49	}
50		50
51	/* Metadata; OpenMG does not support ID3v2.4 */	51	/* Metadata; OpenMG does not support ID3v2.4 */
52	ff_id3v2_write(s, 3, ID3v2_EA3_MAGIC);	52	ff_id3v2_write_simple(s, 3, ID3v2_EA3_MAGIC);
53		53
54	ffio_wfourcc(s->pb, "EA3\0");	54	ffio_wfourcc(s->pb, "EA3\0");
55	avio_w8(s->pb, EA3_HEADER_SIZE >> 7);	55	avio_w8(s->pb, EA3_HEADER_SIZE >> 7);

libavformat/psxstr.c+1−0

@@ -299,4 +299,5 @@ AVInputFormat ff_str_demuxer = { · 298 unmodified lines
299	.read_header = str_read_header,	299	.read_header = str_read_header,
300	.read_packet = str_read_packet,	300	.read_packet = str_read_packet,
301	.read_close = str_read_close,	301	.read_close = str_read_close,
		302	.flags = AVFMT_NO_BYTE_SEEK,
302	};	303	};

libavformat/rtpenc.c+1−1

@@ -112,7 +112,7 @@ static int rtp_write_header(AVFormatContext *s1) · 111 unmodified lines
112		112
113	if (s->max_packet_size) {	113	if (s->max_packet_size) {
114	if (s1->pb->max_packet_size)	114	if (s1->pb->max_packet_size)
115	s->max_packet_size = FFMIN(s->max_payload_size,	115	s->max_packet_size = FFMIN(s->max_packet_size,
116	s1->pb->max_packet_size);	116	s1->pb->max_packet_size);
117	} else	117	} else
118	s->max_packet_size = s1->pb->max_packet_size;	118	s->max_packet_size = s1->pb->max_packet_size;

libavformat/swfdec.c+0−2

             vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
             vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));
             avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);
-            vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
             len -= 8;
         } else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
             /* streaming found */
                 vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                 vst->codec->codec_id = CODEC_ID_MJPEG;
                 avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
-                vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
                 st = vst;
             }
             avio_rl16(pb); /* BITMAP_ID */

libavformat/utils.c+36−19

     return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
 }
+static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
+                               AVPacketList **plast_pktl){
+    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
+    if (!pktl)
+        return NULL;
+    if (*packet_buffer)
+        (*plast_pktl)->next = pktl;
+    else
+        *packet_buffer = pktl;
+    /* add the packet in the buffered packet list */
+    *plast_pktl = pktl;
+    pktl->pkt= *pkt;
+    return &pktl->pkt;
+}
 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
 {
     AVFormatContext *s = *ps;
-    int ret = 0;
+    int i, ret = 0;
     AVDictionary *tmp = NULL;
+    ID3v2ExtraMeta *id3v2_extra_meta = NULL;
     if (!s && !(s = avformat_alloc_context()))
         return AVERROR(ENOMEM);
     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
     if (s->pb)
-        ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
+        ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
         if ((ret = s->iformat->read_header(s)) < 0)
             goto fail;
+    if (id3v2_extra_meta &&
+        (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
+        goto fail;
+    ff_id3v2_free_extra_meta(&id3v2_extra_meta);
+    /* queue attached pictures */
+    for (i = 0; i < s->nb_streams; i++)
+        if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC) {
+            AVPacket copy = s->streams[i]->attached_pic;
+            copy.destruct = NULL;
+            add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
+        }
     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
         s->data_offset = avio_tell(s->pb);
     return 0;
 fail:
+    ff_id3v2_free_extra_meta(&id3v2_extra_meta);
     av_dict_free(&tmp);
     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
         avio_close(s->pb);
 /*******************************************************/
-static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
-                               AVPacketList **plast_pktl){
-    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
-    if (!pktl)
-        return NULL;
-    if (*packet_buffer)
-        (*plast_pktl)->next = pktl;
-    else
-        *packet_buffer = pktl;
-    /* add the packet in the buffered packet list */
-    *plast_pktl = pktl;
-    pktl->pkt= *pkt;
-    return &pktl->pkt;
-}
 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
     int ret, i;
             av_parser_close(st->parser);
             av_free_packet(&st->cur_pkt);
         }
+        if (st->attached_pic.data)
+            av_free_packet(&st->attached_pic);
         av_dict_free(&st->metadata);
         av_freep(&st->index_entries);
         av_freep(&st->codec->extradata);

libavformat/version.h+1−1

@@ -30,7 +30,7 @@ · 29 unmodified lines
30	#include "libavutil/avutil.h"	30	#include "libavutil/avutil.h"
31		31
32	#define LIBAVFORMAT_VERSION_MAJOR 54	32	#define LIBAVFORMAT_VERSION_MAJOR 54
33	#define LIBAVFORMAT_VERSION_MINOR 1	33	#define LIBAVFORMAT_VERSION_MINOR 2
34	#define LIBAVFORMAT_VERSION_MICRO 100	34	#define LIBAVFORMAT_VERSION_MICRO 100
35		35
36	#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \	36	#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \

libavformat/vqf.c+3−3

     int ret;
     int size = (c->frame_bit_len - c->remaining_bits + 7)>>3;
-    pkt->pos          = avio_tell(s->pb);
-    pkt->stream_index = 0;
     if (av_new_packet(pkt, size+2) < 0)
         return AVERROR(EIO);
+    pkt->pos          = avio_tell(s->pb);
+    pkt->stream_index = 0;
     pkt->data[0] = 8 - c->remaining_bits; // Number of bits to skip
     pkt->data[1] = c->last_frame_bits;
     ret = avio_read(s->pb, pkt->data+2, size);

libswscale/utils.c+1−1

@@ -1046,7 +1046,7 @@ int sws_init_context(SwsContext c, SwsFilter srcFilter, SwsFilter *dstFilter) · 1045 unmodified lines
1046	c->vLumBufSize= c->vLumFilterSize;	1046	c->vLumBufSize= c->vLumFilterSize;
1047	c->vChrBufSize= c->vChrFilterSize;	1047	c->vChrBufSize= c->vChrFilterSize;
1048	for (i=0; i<dstH; i++) {	1048	for (i=0; i<dstH; i++) {
1049	int chrI= (int64_t)i*c->chrDstH / dstH;	1049	int chrI = (int64_t) i * c->chrDstH / dstH;
1050	int nextSlice= FFMAX(c->vLumFilterPos[i ] + c->vLumFilterSize - 1,	1050	int nextSlice= FFMAX(c->vLumFilterPos[i ] + c->vLumFilterSize - 1,
1051	((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<c->chrSrcVSubSample));	1051	((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<c->chrSrcVSubSample));
1052		1052

tests/codec-regression.sh+3−3

@@ -38,13 +38,13 @@ fi · 37 unmodified lines
38		38
39	if [ -n "$do_mpeg2_ivlc_qprd" ]; then	39	if [ -n "$do_mpeg2_ivlc_qprd" ]; then
40	# mpeg2 encoding intra vlc qprd	40	# mpeg2 encoding intra vlc qprd
41	do_video_encoding mpeg2ivlc-qprd.mpg "-vb 500k -bf 2 -trellis 1 -flags +qprd+mv0 -intra_vlc 1 -cmp 2 -subcmp 2 -mbd rd -vcodec mpeg2video -f mpeg2video"	41	do_video_encoding mpeg2ivlc-qprd.mpg "-vb 500k -bf 2 -trellis 1 -flags +mv0 -mpv_flags +qp_rd -intra_vlc 1 -cmp 2 -subcmp 2 -mbd rd -vcodec mpeg2video -f mpeg2video"
42	do_video_decoding	42	do_video_decoding
43	fi	43	fi
44		44
45	if [ -n "$do_mpeg2_422" ]; then	45	if [ -n "$do_mpeg2_422" ]; then
46	#mpeg2 4:2:2 encoding	46	#mpeg2 4:2:2 encoding
47	do_video_encoding mpeg2_422.mpg "-vb 1000k -bf 2 -trellis 1 -flags +qprd+mv0+ildct+ilme -intra_vlc 1 -mbd rd -vcodec mpeg2video -pix_fmt yuv422p -f mpeg2video"	47	do_video_encoding mpeg2_422.mpg "-vb 1000k -bf 2 -trellis 1 -flags +mv0+ildct+ilme -mpv_flags +qp_rd -intra_vlc 1 -mbd rd -vcodec mpeg2video -pix_fmt yuv422p -f mpeg2video"
48	do_video_decoding	48	do_video_decoding
49	fi	49	fi
50		50
@@ -143,7 +143,7 @@ do_video_decoding · 92 unmodified lines
143	fi	143	fi
144		144
145	if [ -n "$do_mpeg4_qprd" ]; then	145	if [ -n "$do_mpeg4_qprd" ]; then
146	do_video_encoding mpeg4-qprd.avi "-b 450k -bf 2 -trellis 1 -flags +mv4+qprd+mv0 -cmp 2 -subcmp 2 -mbd rd -an -vcodec mpeg4"	146	do_video_encoding mpeg4-qprd.avi "-b 450k -bf 2 -trellis 1 -flags +mv4+mv0 -mpv_flags +qp_rd -cmp 2 -subcmp 2 -mbd rd -an -vcodec mpeg4"
147	do_video_decoding	147	do_video_decoding
148	fi	148	fi
149		149

tests/fate/cdxl.mak+3−0

@@ -10,5 +10,8 @@ fate-cdxl-pal8: CMD = framecrc -i $(SAMPLES)/cdxl/maku.cdxl -pix_fmt rgb24 -fram · 9 unmodified lines
10	FATE_CDXL += fate-cdxl-pal8-small	10	FATE_CDXL += fate-cdxl-pal8-small
11	fate-cdxl-pal8-small: CMD = framecrc -i $(SAMPLES)/cdxl/fruit.cdxl -an -pix_fmt rgb24 -frames:v 46	11	fate-cdxl-pal8-small: CMD = framecrc -i $(SAMPLES)/cdxl/fruit.cdxl -an -pix_fmt rgb24 -frames:v 46
12		12
		13	FATE_CDXL += fate-cdxl-bitline-ham6
		14	fate-cdxl-bitline-ham6: CMD = framecrc -i $(SAMPLES)/cdxl/bitline.cdxl -frames:v 10
		15
13	FATE_TESTS += $(FATE_CDXL)	16	FATE_TESTS += $(FATE_CDXL)
14	fate-cdxl: $(FATE_CDXL)	17	fate-cdxl: $(FATE_CDXL)

tests/fate/mp3.mak+5−0

 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_TESTS += $(FATE_MP3)
 fate-mp3: $(FATE_MP3)
 $(FATE_MP3): CMP = stddev

tests/fate/video.mak+1−1

@@ -143,7 +143,7 @@ FATE_VIDEO += fate-mpeg2-field-enc · 142 unmodified lines
143	fate-mpeg2-field-enc: CMD = framecrc -flags +bitexact -dct fastint -idct simple -i $(SAMPLES)/mpeg2/mpeg2_field_encoding.ts -an	143	fate-mpeg2-field-enc: CMD = framecrc -flags +bitexact -dct fastint -idct simple -i $(SAMPLES)/mpeg2/mpeg2_field_encoding.ts -an
144		144
145	FATE_VIDEO += fate-nuv	145	FATE_VIDEO += fate-nuv
146	fate-nuv: CMD = framecrc -idct simple -i $(SAMPLES)/nuv/Today.nuv	146	fate-nuv: CMD = framecrc -idct simple -i $(SAMPLES)/nuv/Today.nuv -an
147		147
148	FATE_VIDEO += fate-qpeg	148	FATE_VIDEO += fate-qpeg
149	fate-qpeg: CMD = framecrc -i $(SAMPLES)/qpeg/Clock.avi -an -pix_fmt rgb24	149	fate-qpeg: CMD = framecrc -i $(SAMPLES)/qpeg/Clock.avi -an -pix_fmt rgb24

tests/ref/fate/cdxl-bitline-ham6+11−0

@@ -0,0 +1,11 @@
	1	#tb 0: 12/601
	2	0, 0, 0, 1, 63180, 0xcda82c16
	3	0, 1, 1, 1, 63180, 0xa6097bf9
	4	0, 2, 2, 1, 63180, 0x4c2fb091
	5	0, 3, 3, 1, 63180, 0xc597db00
	6	0, 4, 4, 1, 63180, 0xfa581ccd
	7	0, 5, 5, 1, 63180, 0x3e51498f
	8	0, 6, 6, 1, 63180, 0xe3495396
	9	0, 7, 7, 1, 63180, 0x425f5f02
	10	0, 8, 8, 1, 63180, 0x6077465f
	11	0, 9, 9, 1, 63180, 0x923ba29c

tests/ref/fate/nuv+0−19

@@ -1,29 +1,10 @@
1	#tb 0: 100/2997	1	#tb 0: 100/2997
2	#tb 1: 1/44100
3	1, 0, 0, 1024, 4096, 0x00000000
4	1, 1024, 1024, 1024, 4096, 0x4dfae7a6
5	1, 2048, 2048, 1024, 4096, 0x3fd9f5c6
6	1, 3072, 3072, 1024, 4096, 0x7b86e310
7	1, 4096, 4096, 1024, 4096, 0x611cece5
8	1, 5120, 5120, 1024, 4096, 0xb7d8e872
9	0, 4, 4, 1, 460800, 0x54aedafe	2	0, 4, 4, 1, 460800, 0x54aedafe
10	1, 6144, 6144, 1024, 4096, 0x072ef72b
11	1, 7168, 7168, 1024, 4096, 0xb3560144
12	0, 5, 5, 1, 460800, 0xb7aa8b56	3	0, 5, 5, 1, 460800, 0xb7aa8b56
13	1, 8192, 8192, 1024, 4096, 0x0a3d119e
14	0, 6, 6, 1, 460800, 0x283ea3b5	4	0, 6, 6, 1, 460800, 0x283ea3b5
15	1, 9216, 9216, 1024, 4096, 0xbe391aa4
16	1, 10240, 10240, 1024, 4096, 0x28f7c6e5
17	0, 7, 7, 1, 460800, 0x283ea3b5	5	0, 7, 7, 1, 460800, 0x283ea3b5
18	1, 11264, 11264, 1024, 4096, 0xca9d9df2
19	0, 8, 8, 1, 460800, 0x10e577de	6	0, 8, 8, 1, 460800, 0x10e577de
20	1, 12288, 12288, 1024, 4096, 0x5c6b95a9
21	0, 9, 9, 1, 460800, 0x4e091ee2	7	0, 9, 9, 1, 460800, 0x4e091ee2
22	1, 13312, 13312, 1024, 4096, 0x0bdfc0bf
23	1, 14336, 14336, 1024, 4096, 0xd95a9277
24	0, 10, 10, 1, 460800, 0x2ea88828	8	0, 10, 10, 1, 460800, 0x2ea88828
25	1, 15360, 15360, 1024, 4096, 0xae2bef2c
26	0, 11, 11, 1, 460800, 0x4b7f4df0	9	0, 11, 11, 1, 460800, 0x4b7f4df0
27	1, 16384, 16384, 1024, 4096, 0xbf031e83
28	1, 17408, 17408, 1024, 4096, 0x4c83e2d1
29	0, 12, 12, 1, 460800, 0xa57f20d0	10	0, 12, 12, 1, 460800, 0xa57f20d0

tests/ref/lavf/ffm+1−1

@@ -1,3 +1,3 @@
1	4ef091d638bb20b8eaef5b3a0d6f97b7 *./tests/data/lavf/lavf.ffm	1	8ce2ea9a73a1187647df7bf3c8e1b8fd *./tests/data/lavf/lavf.ffm
2	376832 ./tests/data/lavf/lavf.ffm	2	376832 ./tests/data/lavf/lavf.ffm
3	./tests/data/lavf/lavf.ffm CRC=0xf361ed74	3	./tests/data/lavf/lavf.ffm CRC=0xf361ed74

tests/ref/vsynth1/prores_kostya+1−1

@@ -1,4 +1,4 @@
1	40e7637e04991dbe9a23fe109f95bfc8 *./tests/data/vsynth1/prores_kostya.mov	1	f8fe98b7f9bb66857c81dbca409a9037 *./tests/data/vsynth1/prores_kostya.mov
2	3858901 ./tests/data/vsynth1/prores_kostya.mov	2	3858901 ./tests/data/vsynth1/prores_kostya.mov
3	0a4153637d0cc0a88a8bcbf04cfaf8c6 *./tests/data/prores_kostya.vsynth1.out.yuv	3	0a4153637d0cc0a88a8bcbf04cfaf8c6 *./tests/data/prores_kostya.vsynth1.out.yuv
4	stddev: 3.17 PSNR: 38.09 MAXDIFF: 39 bytes: 7603200/ 7603200	4	stddev: 3.17 PSNR: 38.09 MAXDIFF: 39 bytes: 7603200/ 7603200

tests/ref/vsynth2/prores_kostya+1−1

@@ -1,4 +1,4 @@
1	ed8b8a94da049518af8f95c5da736e57 *./tests/data/vsynth2/prores_kostya.mov	1	26adb18726c08dde23bc4bee2eb591e2 *./tests/data/vsynth2/prores_kostya.mov
2	3884586 ./tests/data/vsynth2/prores_kostya.mov	2	3884586 ./tests/data/vsynth2/prores_kostya.mov
3	ca2f6c1162635dedfa468c90f1fdc0ef *./tests/data/prores_kostya.vsynth2.out.yuv	3	ca2f6c1162635dedfa468c90f1fdc0ef *./tests/data/prores_kostya.vsynth2.out.yuv
4	stddev: 0.92 PSNR: 48.77 MAXDIFF: 10 bytes: 7603200/ 7603200	4	stddev: 0.92 PSNR: 48.77 MAXDIFF: 10 bytes: 7603200/ 7603200

Merge remote-tracking branch 'qatar/master'

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code