sigrid/ffmpeg

configure+11−1

     isatty
     kbhit
     ldbrx
+    libdc1394_1
+    libdc1394_2
     llrint
     llrintf
     local_aligned_16
 enabled avisynth   && require2 vfw32 "windows.h vfw.h" AVIFileInit -lavifil32
 enabled libcelt    && require libcelt celt/celt.h celt_decode -lcelt0
 enabled frei0r     && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }
-enabled libdc1394  && require_pkg_config libdc1394-2 dc1394/dc1394.h dc1394_new
 enabled libdirac   && require_pkg_config dirac                          \
     "libdirac_decoder/dirac_parser.h libdirac_encoder/dirac_encoder.h"  \
     "dirac_decoder_init dirac_encoder_init"
 enabled libxvid    && require  libxvid xvid.h xvid_global -lxvidcore
 enabled mlib       && require  mediaLib mlib_types.h mlib_VectorSub_S16_U8_Mod -lmlib
+# libdc1394 check
+if enabled libdc1394; then
+    { check_lib dc1394/dc1394.h dc1394_new -ldc1394 -lraw1394 &&
+        enable libdc1394_2; } ||
+    { check_lib libdc1394/dc1394_control.h dc1394_create_handle -ldc1394_control -lraw1394 &&
+        enable libdc1394_1; } ||
+    die "ERROR: No version of libdc1394 found "
+fi
 SDL_CONFIG="${cross_prefix}sdl-config"
 if check_pkg_config sdl SDL_version.h SDL_Linked_Version; then
     check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x010201" $sdl_cflags &&

ffmpeg.c+2−3

             }
         }
         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
-                  0, ost->resample_height, ost->resample_frame.data, ost->resample_frame.linesize);
+              0, ost->resample_height, final_picture->data, final_picture->linesize);
     }
 #endif
 static void new_data_stream(AVFormatContext *oc, int file_idx)
 {
     AVStream *st;
-    AVOutputStream *ost av_unused;
     AVCodec *codec=NULL;
     AVCodecContext *data_enc;
         fprintf(stderr, "Could not alloc stream\n");
         ffmpeg_exit(1);
     }
-    ost = new_output_stream(oc, file_idx);
+    new_output_stream(oc, file_idx);
     data_enc = st->codec;
     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
     if (!data_stream_copy) {

ffserver.c+2−2

@@ -1760,7 +1760,7 @@ static int http_parse_request(HTTPContext *c) · 1759 unmodified lines
1760	}	1760	}
1761	}	1761	}
1762		1762
1763	#ifdef DEBUG_WMP	1763	#ifdef DEBUG
1764	http_log("\nGot request:\n%s\n", c->buffer);	1764	http_log("\nGot request:\n%s\n", c->buffer);
1765	#endif	1765	#endif
1766		1766
@@ -1790,7 +1790,7 @@ static int http_parse_request(HTTPContext *c) · 23 unmodified lines
1790	return 0;	1790	return 0;
1791	}	1791	}
1792		1792
1793	#ifdef DEBUG_WMP	1793	#ifdef DEBUG
1794	if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)	1794	if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1795	http_log("\nGot request:\n%s\n", c->buffer);	1795	http_log("\nGot request:\n%s\n", c->buffer);
1796	#endif	1796	#endif

libavcodec/aaccoder.c+3−6

                                      int win, int group_len, const float lambda)
 {
     BandCodingPath path[120][12];
-    int w, swb, cb, start, start2, size;
+    int w, swb, cb, start, size;
     int i, j;
     const int max_sfb  = sce->ics.max_sfb;
     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
         path[0][cb].run      = 0;
     }
     for (swb = 0; swb < max_sfb; swb++) {
-        start2 = start;
         size = sce->ics.swb_sizes[swb];
         if (sce->zeroes[win*16 + swb]) {
             for (cb = 0; cb < 12; cb++) {
                                   int win, int group_len, const float lambda)
 {
     BandCodingPath path[120][12];
-    int w, swb, cb, start, start2, size;
+    int w, swb, cb, start, size;
     int i, j;
     const int max_sfb  = sce->ics.max_sfb;
     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
         path[0][cb].run      = 0;
     }
     for (swb = 0; swb < max_sfb; swb++) {
-        start2 = start;
         size = sce->ics.swb_sizes[swb];
         if (sce->zeroes[win*16 + swb]) {
             for (cb = 0; cb < 12; cb++) {
                                        SingleChannelElement *sce,
                                        const float lambda)
 {
-    int start = 0, i, w, w2, g;
+    int i, w, w2, g;
     int minq = 255;
     memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
-        start = w*128;
         for (g = 0; g < sce->ics.num_swb; g++) {
             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
                 FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];

libavcodec/aacenc.c+29−3

  * add temporal noise shaping
  ***********************************/
+#include "libavutil/opt.h"
 #include "avcodec.h"
 #include "put_bits.h"
 #include "dsputil.h"
     AACEncContext *s = avctx->priv_data;
     int16_t *samples = s->samples, *samples2, *la;
     ChannelElement *cpe;
-    int i, ch, w, chans, tag, start_ch;
+    int i, ch, w, g, chans, tag, start_ch;
     const uint8_t *chan_map = aac_chan_configs[avctx->channels-1];
     int chan_el_counter[4];
     FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
                 }
             }
             s->cur_channel = start_ch;
-            if (cpe->common_window && s->coder->search_for_ms)
+            if (s->options.stereo_mode && cpe->common_window) {
-                s->coder->search_for_ms(s, cpe, s->lambda);
+                if (s->options.stereo_mode > 0) {
+                    IndividualChannelStream *ics = &cpe->ch[0].ics;
+                    for (w = 0; w < ics->num_windows; w += ics->group_len[w])
+                        for (g = 0;  g < ics->num_swb; g++)
+                            cpe->ms_mask[w*16+g] = 1;
+                } else if (s->coder->search_for_ms) {
+                    s->coder->search_for_ms(s, cpe, s->lambda);
+                }
+            }
             adjust_frame_information(s, cpe, chans);
             if (chans == 2) {
                 put_bits(&s->pb, 1, cpe->common_window);
     return 0;
 }
+#define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
+static const AVOption aacenc_options[] = {
+    {"stereo_mode", "Stereo coding method", offsetof(AACEncContext, options.stereo_mode), FF_OPT_TYPE_INT, {.dbl = 0}, -1, 1, AACENC_FLAGS, "stereo_mode"},
+        {"auto",     "Selected by the Encoder", 0, FF_OPT_TYPE_CONST, {.dbl = -1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
+        {"ms_off",   "Disable Mid/Side coding", 0, FF_OPT_TYPE_CONST, {.dbl =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
+        {"ms_force", "Force Mid/Side for the whole frame if possible", 0, FF_OPT_TYPE_CONST, {.dbl =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
+    {NULL}
+};
+static const AVClass aacenc_class = {
+    "AAC encoder",
+    av_default_item_name,
+    aacenc_options,
+    LIBAVUTIL_VERSION_INT,
+};
 AVCodec ff_aac_encoder = {
     "aac",
     AVMEDIA_TYPE_AUDIO,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,
     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
+    .priv_class = &aacenc_class,
 };

libavcodec/aacenc.h+6−0

 #include "psymodel.h"
+typedef struct AACEncOptions {
+    int stereo_mode;
+} AACEncOptions;
 struct AACEncContext;
 typedef struct AACCoefficientsEncoder {
  * AAC encoder context
  */
 typedef struct AACEncContext {
+    AVClass *av_class;
+    AACEncOptions options;                       ///< encoding options
     PutBitContext pb;
     FFTContext mdct1024;                         ///< long (1024 samples) frame transform context
     FFTContext mdct128;                          ///< short (128 samples) frame transform context

libavcodec/cook.c+2−36

@@ -66,7 +66,6 @@ · 65 unmodified lines
66		66
67	#define SUBBAND_SIZE 20	67	#define SUBBAND_SIZE 20
68	#define MAX_SUBPACKETS 5	68	#define MAX_SUBPACKETS 5
69	//#define COOKDEBUG
70		69
71	typedef struct {	70	typedef struct {
72	int *now;	71	int *now;
@@ -166,38 +165,6 @@ typedef struct cook { · 93 unmodified lines
166	static float pow2tab[127];	165	static float pow2tab[127];
167	static float rootpow2tab[127];	166	static float rootpow2tab[127];
168		167
169	/* debug functions */
170
171	#ifdef COOKDEBUG
172	static void dump_float_table(float* table, int size, int delimiter) {
173	int i=0;
174	av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
175	for (i=0 ; i<size ; i++) {
176	av_log(NULL, AV_LOG_ERROR, "%5.1f, ", table[i]);
177	if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
178	}
179	}
180
181	static void dump_int_table(int* table, int size, int delimiter) {
182	int i=0;
183	av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
184	for (i=0 ; i<size ; i++) {
185	av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
186	if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
187	}
188	}
189
190	static void dump_short_table(short* table, int size, int delimiter) {
191	int i=0;
192	av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i);
193	for (i=0 ; i<size ; i++) {
194	av_log(NULL, AV_LOG_ERROR, "%d, ", table[i]);
195	if ((i+1)%delimiter == 0) av_log(NULL,AV_LOG_ERROR,"\n[%d]: ",i+1);
196	}
197	}
198
199	#endif
200
201	/************* init functions *************/	168	/************* init functions *************/
202		169
203	/* table generator */	170	/* table generator */
@@ -1037,7 +1004,7 @@ static int cook_decode_frame(AVCodecContext *avctx, · 833 unmodified lines
1037	return avctx->block_align;	1004	return avctx->block_align;
1038	}	1005	}
1039		1006
1040	#ifdef COOKDEBUG	1007	#ifdef DEBUG
1041	static void dump_cook_context(COOKContext *q)	1008	static void dump_cook_context(COOKContext *q)
1042	{	1009	{
1043	//int i=0;	1010	//int i=0;
@@ -1055,7 +1022,6 @@ static void dump_cook_context(COOKContext *q) · 11 unmodified lines
1055	PRINT("samples_per_channel",q->subpacket[0].samples_per_channel);	1022	PRINT("samples_per_channel",q->subpacket[0].samples_per_channel);
1056	PRINT("samples_per_frame",q->subpacket[0].samples_per_frame);	1023	PRINT("samples_per_frame",q->subpacket[0].samples_per_frame);
1057	PRINT("subbands",q->subpacket[0].subbands);	1024	PRINT("subbands",q->subpacket[0].subbands);
1058	PRINT("random_state",q->random_state);
1059	PRINT("js_subband_start",q->subpacket[0].js_subband_start);	1025	PRINT("js_subband_start",q->subpacket[0].js_subband_start);
1060	PRINT("log2_numvector_size",q->subpacket[0].log2_numvector_size);	1026	PRINT("log2_numvector_size",q->subpacket[0].log2_numvector_size);
1061	PRINT("numvector_size",q->subpacket[0].numvector_size);	1027	PRINT("numvector_size",q->subpacket[0].numvector_size);
@@ -1280,7 +1246,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx) · 218 unmodified lines
1280	else	1246	else
1281	avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;	1247	avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
1282		1248
1283	#ifdef COOKDEBUG	1249	#ifdef DEBUG
1284	dump_cook_context(q);	1250	dump_cook_context(q);
1285	#endif	1251	#endif
1286	return 0;	1252	return 0;

libavcodec/dca.c+2−4

 {
     int ss_index;
     int blownup;
-    int header_size av_unused;
-    int hd_size av_unused;
     int num_audiop = 1;
     int num_assets = 1;
     int active_ss_mask[8];
     ss_index = get_bits(&s->gb, 2);
     blownup = get_bits1(&s->gb);
-    header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;
+    skip_bits(&s->gb, 8 + 4 * blownup); // header_size
-    hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
+    skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
     s->static_fields = get_bits1(&s->gb);
     if (s->static_fields) {

libavcodec/dirac.c+2−2

@@ -245,11 +245,11 @@ static int parse_source_parameters(AVCodecContext avctx, GetBitContext gb, · 244 unmodified lines
245	int ff_dirac_parse_sequence_header(AVCodecContext avctx, GetBitContext gb,	245	int ff_dirac_parse_sequence_header(AVCodecContext avctx, GetBitContext gb,
246	dirac_source_params *source)	246	dirac_source_params *source)
247	{	247	{
248	unsigned version_major, version_minor av_unused;	248	unsigned version_major;
249	unsigned video_format, picture_coding_mode;	249	unsigned video_format, picture_coding_mode;
250		250
251	version_major = svq3_get_ue_golomb(gb);	251	version_major = svq3_get_ue_golomb(gb);
252	version_minor = svq3_get_ue_golomb(gb);	252	svq3_get_ue_golomb(gb); /* version_minor */
253	avctx->profile = svq3_get_ue_golomb(gb);	253	avctx->profile = svq3_get_ue_golomb(gb);
254	avctx->level = svq3_get_ue_golomb(gb);	254	avctx->level = svq3_get_ue_golomb(gb);
255	video_format = svq3_get_ue_golomb(gb);	255	video_format = svq3_get_ue_golomb(gb);

libavcodec/error_resilience.c+38−7

 #include "mpegvideo.h"
 #include "h264.h"
 #include "rectangle.h"
+#include "thread.h"
 /*
  * H264 redefines mb_intra so it is not mistakely used (its uninitialized in h264)
                     int best_score=256*256*256*64;
                     int best_pred=0;
                     const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
-                    int prev_x= s->current_picture.motion_val[0][mot_index][0];
+                    int prev_x, prev_y, prev_ref;
-                    int prev_y= s->current_picture.motion_val[0][mot_index][1];
                     if((mb_x^mb_y^pass)&1) continue;
                     /* zero MV */
                     pred_count++;
+                    if (!fixed[mb_xy] && 0) {
+                        if (s->avctx->codec_id == CODEC_ID_H264) {
+                            // FIXME
+                        } else {
+                            ff_thread_await_progress((AVFrame *) s->last_picture_ptr,
+                                                     mb_y, 0);
+                        }
+                        prev_x = s->last_picture.motion_val[0][mot_index][0];
+                        prev_y = s->last_picture.motion_val[0][mot_index][1];
+                        prev_ref = s->last_picture.ref_index[0][4*mb_xy];
+                    } else {
+                        prev_x = s->current_picture.motion_val[0][mot_index][0];
+                        prev_y = s->current_picture.motion_val[0][mot_index][1];
+                        prev_ref = s->current_picture.ref_index[0][4*mb_xy];
+                    }
                     /* last MV */
-                    mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index][0];
+                    mv_predictor[pred_count][0]= prev_x;
-                    mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index][1];
+                    mv_predictor[pred_count][1]= prev_y;
-                    ref         [pred_count]   = s->current_picture.ref_index[0][4*mb_xy];
+                    ref         [pred_count]   = prev_ref;
                     pred_count++;
                     s->mv_dir = MV_DIR_FORWARD;
                 uint8_t *mb_ptr     = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
                 uint8_t *last_mb_ptr= s->last_picture.data   [0] + mb_x*16 + mb_y*16*s->linesize;
+                if (s->avctx->codec_id == CODEC_ID_H264) {
+                    // FIXME
+                } else {
+                    ff_thread_await_progress((AVFrame *) s->last_picture_ptr,
+                                             mb_y, 0);
+                }
                 is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr                    , s->linesize, 16);
                 // FIXME need await_progress() here
                 is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16);
     memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_stride*s->mb_height*sizeof(uint8_t));
     s->error_count= 3*s->mb_num;
+    s->error_occurred = 0;
 }
 /**
         s->error_count -= end_i - start_i + 1;
     }
-    if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) s->error_count= INT_MAX;
+    if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) {
+        s->error_occurred = 1;
+        s->error_count= INT_MAX;
+    }
     if(mask == ~0x7F){
         memset(&s->error_status_table[start_xy], 0, (end_xy - start_xy) * sizeof(uint8_t));
                     int time_pp= s->pp_time;
                     int time_pb= s->pb_time;
-                    // FIXME await_progress here
+                    if (s->avctx->codec_id == CODEC_ID_H264) {
+                        //FIXME
+                    } else {
+                        ff_thread_await_progress((AVFrame *) s->next_picture_ptr,
+                                                 mb_y, 0);
+                    }
                     s->mv[0][0][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp;
                     s->mv[0][0][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp;
                     s->mv[1][0][0] = s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;

libavcodec/h263dec.c+3−0

             if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
                 break;
         }else{
+            int prev_x=s->mb_x, prev_y=s->mb_y;
             if(ff_h263_resync(s)<0)
                 break;
+            if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)
+                s->error_occurred = 1;
         }
         if(s->msmpeg4_version<4 && s->h263_pred)

libavcodec/h264.c+142−10

@@ -246,6 +246,141 @@ static int ff_h264_decode_rbsp_trailing(H264Context h, const uint8_t src){ · 245 unmodified lines
246	return 0;	246	return 0;
247	}	247	}
248		248
		249	static inline int get_lowest_part_list_y(H264Context h, Picture pic, int n, int height,
		250	int y_offset, int list){
		251	int raw_my= h->mv_cache[list][ scan8[n] ][1];
		252	int filter_height= (raw_my&3) ? 2 : 0;
		253	int full_my= (raw_my>>2) + y_offset;
		254	int top = full_my - filter_height, bottom = full_my + height + filter_height;
		255
		256	return FFMAX(abs(top), bottom);
		257	}
		258
		259	static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n, int height,
		260	int y_offset, int list0, int list1, int *nrefs){
		261	MpegEncContext * const s = &h->s;
		262	int my;
		263
		264	y_offset += 16*(s->mb_y >> MB_FIELD);
		265
		266	if(list0){
		267	int ref_n = h->ref_cache[0][ scan8[n] ];
		268	Picture *ref= &h->ref_list[0][ref_n];
		269
		270	// Error resilience puts the current picture in the ref list.
		271	// Don't try to wait on these as it will cause a deadlock.
		272	// Fields can wait on each other, though.
		273	if(ref->thread_opaque != s->current_picture.thread_opaque \|\|
		274	(ref->reference&3) != s->picture_structure) {
		275	my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);
		276	if (refs[0][ref_n] < 0) nrefs[0] += 1;
		277	refs[0][ref_n] = FFMAX(refs[0][ref_n], my);
		278	}
		279	}
		280
		281	if(list1){
		282	int ref_n = h->ref_cache[1][ scan8[n] ];
		283	Picture *ref= &h->ref_list[1][ref_n];
		284
		285	if(ref->thread_opaque != s->current_picture.thread_opaque \|\|
		286	(ref->reference&3) != s->picture_structure) {
		287	my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);
		288	if (refs[1][ref_n] < 0) nrefs[1] += 1;
		289	refs[1][ref_n] = FFMAX(refs[1][ref_n], my);
		290	}
		291	}
		292	}
		293
		294	/**
		295	* Wait until all reference frames are available for MC operations.
		296	*
		297	* @param h the H264 context
		298	*/
		299	static void await_references(H264Context *h){
		300	MpegEncContext * const s = &h->s;
		301	const int mb_xy= h->mb_xy;
		302	const int mb_type= s->current_picture.mb_type[mb_xy];
		303	int refs[2][48];
		304	int nrefs[2] = {0};
		305	int ref, list;
		306
		307	memset(refs, -1, sizeof(refs));
		308
		309	if(IS_16X16(mb_type)){
		310	get_lowest_part_y(h, refs, 0, 16, 0,
		311	IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
		312	}else if(IS_16X8(mb_type)){
		313	get_lowest_part_y(h, refs, 0, 8, 0,
		314	IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
		315	get_lowest_part_y(h, refs, 8, 8, 8,
		316	IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
		317	}else if(IS_8X16(mb_type)){
		318	get_lowest_part_y(h, refs, 0, 16, 0,
		319	IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
		320	get_lowest_part_y(h, refs, 4, 16, 0,
		321	IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
		322	}else{
		323	int i;
		324
		325	assert(IS_8X8(mb_type));
		326
		327	for(i=0; i<4; i++){
		328	const int sub_mb_type= h->sub_mb_type[i];
		329	const int n= 4*i;
		330	int y_offset= (i&2)<<2;
		331
		332	if(IS_SUB_8X8(sub_mb_type)){
		333	get_lowest_part_y(h, refs, n , 8, y_offset,
		334	IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
		335	}else if(IS_SUB_8X4(sub_mb_type)){
		336	get_lowest_part_y(h, refs, n , 4, y_offset,
		337	IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
		338	get_lowest_part_y(h, refs, n+2, 4, y_offset+4,
		339	IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
		340	}else if(IS_SUB_4X8(sub_mb_type)){
		341	get_lowest_part_y(h, refs, n , 8, y_offset,
		342	IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
		343	get_lowest_part_y(h, refs, n+1, 8, y_offset,
		344	IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
		345	}else{
		346	int j;
		347	assert(IS_SUB_4X4(sub_mb_type));
		348	for(j=0; j<4; j++){
		349	int sub_y_offset= y_offset + 2*(j&2);
		350	get_lowest_part_y(h, refs, n+j, 4, sub_y_offset,
		351	IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
		352	}
		353	}
		354	}
		355	}
		356
		357	for(list=h->list_count-1; list>=0; list--){
		358	for(ref=0; ref<48 && nrefs[list]; ref++){
		359	int row = refs[list][ref];
		360	if(row >= 0){
		361	Picture *ref_pic = &h->ref_list[list][ref];
		362	int ref_field = ref_pic->reference - 1;
		363	int ref_field_picture = ref_pic->field_picture;
		364	int pic_height = 16*s->mb_height >> ref_field_picture;
		365
		366	row <<= MB_MBAFF;
		367	nrefs[list]--;
		368
		369	if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields
		370	ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);
		371	ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) , pic_height-1), 0);
		372	}else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame
		373	ff_thread_await_progress((AVFrame)ref_pic, FFMIN(row2 + ref_field , pic_height-1), 0);
		374	}else if(FIELD_PICTURE){
		375	ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);
		376	}else{
		377	ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);
		378	}
		379	}
		380	}
		381	}
		382	}
		383
249	#if 0	384	#if 0
250	/**	385	/**
251	* DCT transforms the 16 dc values.	386	* DCT transforms the 16 dc values.
@@ -315,6 +450,7 @@ static void chroma_dc_dct_c(DCTELEM *block){ · 63 unmodified lines
315	static void free_tables(H264Context *h, int free_rbsp){	450	static void free_tables(H264Context *h, int free_rbsp){
316	int i;	451	int i;
317	H264Context *hx;	452	H264Context *hx;
		453
318	av_freep(&h->intra4x4_pred_mode);	454	av_freep(&h->intra4x4_pred_mode);
319	av_freep(&h->chroma_pred_mode_table);	455	av_freep(&h->chroma_pred_mode_table);
320	av_freep(&h->cbp_table);	456	av_freep(&h->cbp_table);
@@ -611,6 +747,7 @@ av_cold int ff_h264_decode_init(AVCodecContext *avctx){ · 290 unmodified lines
611	return 0;	747	return 0;
612	}	748	}
613		749
		750
614	#define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b)+(size))))	751	#define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b)+(size))))
615	static void copy_picture_range(Picture to, Picture from, int count, MpegEncContext new_base, MpegEncContext old_base)	752	static void copy_picture_range(Picture to, Picture from, int count, MpegEncContext new_base, MpegEncContext old_base)
616	{	753	{
@@ -711,7 +848,8 @@ static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContex · 94 unmodified lines
711	copy_fields(h, h1, poc_lsb, redundant_pic_count);	848	copy_fields(h, h1, poc_lsb, redundant_pic_count);
712		849
713	//reference lists	850	//reference lists
714	copy_fields(h, h1, ref_count, intra_gb);	851	copy_fields(h, h1, ref_count, list_count);
		852	copy_fields(h, h1, ref_list, intra_gb);
715	copy_fields(h, h1, short_ref, cabac_init_idc);	853	copy_fields(h, h1, short_ref, cabac_init_idc);
716		854
717	copy_picture_range(h->short_ref, h1->short_ref, 32, s, s1);	855	copy_picture_range(h->short_ref, h1->short_ref, 32, s, s1);
@@ -738,6 +876,7 @@ int ff_h264_frame_start(H264Context *h){ · 20 unmodified lines
738	MpegEncContext * const s = &h->s;	876	MpegEncContext * const s = &h->s;
739	int i;	877	int i;
740	const int pixel_shift = h->pixel_shift;	878	const int pixel_shift = h->pixel_shift;
		879	int thread_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;
741		880
742	if(MPV_frame_start(s, s->avctx) < 0)	881	if(MPV_frame_start(s, s->avctx) < 0)
743	return -1;	882	return -1;
@@ -766,7 +905,7 @@ int ff_h264_frame_start(H264Context *h){ · 22 unmodified lines
766		905
767	/* can't be in alloc_tables because linesize isn't known there.	906	/* can't be in alloc_tables because linesize isn't known there.
768	* FIXME: redo bipred weight to not require extra buffer? */	907	* FIXME: redo bipred weight to not require extra buffer? */
769	for(i = 0; i < s->avctx->thread_count; i++)	908	for(i = 0; i < thread_count; i++)
770	if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)	909	if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)
771	h->thread_context[i]->s.obmc_scratchpad = av_malloc(162s->linesize + 82s->uvlinesize);	910	h->thread_context[i]->s.obmc_scratchpad = av_malloc(162s->linesize + 82s->uvlinesize);
772		911
@@ -2910,12 +3049,6 @@ static int decode_nal_units(H264Context h, const uint8_t buf, int buf_size){ · 2137 unmodified lines
2910	int nal_index;	3049	int nal_index;
2911		3050
2912	h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;	3051	h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;
2913	#if 0
2914	int i;
2915	for(i=0; i<50; i++){
2916	av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
2917	}
2918	#endif
2919	if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){	3052	if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){
2920	h->current_slice = 0;	3053	h->current_slice = 0;
2921	if (!s->first_field)	3054	if (!s->first_field)
@@ -3491,8 +3624,7 @@ AVCodec ff_h264_decoder = { · 569 unmodified lines
3491	ff_h264_decode_end,	3624	ff_h264_decode_end,
3492	decode_frame,	3625	decode_frame,
3493	/CODEC_CAP_DRAW_HORIZ_BAND \|/ CODEC_CAP_DR1 \| CODEC_CAP_DELAY \|	3626	/CODEC_CAP_DRAW_HORIZ_BAND \|/ CODEC_CAP_DR1 \| CODEC_CAP_DELAY \|
3494	CODEC_CAP_FRAME_THREADS \|	3627	CODEC_CAP_SLICE_THREADS \| CODEC_CAP_FRAME_THREADS,
3495	CODEC_CAP_SLICE_THREADS,
3496	.flush= flush_dpb,	3628	.flush= flush_dpb,
3497	.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),	3629	.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
3498	.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),	3630	.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

libavcodec/indeo5.c+1−1

@@ -629,7 +629,7 @@ static int decode_band(IVI5DecContext *ctx, int plane_num, · 628 unmodified lines
629	FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);	629	FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
630	}	630	}
631		631
632	#if IVI_DEBUG	632	#ifdef DEBUG
633	if (band->checksum_present) {	633	if (band->checksum_present) {
634	uint16_t chksum = ivi_calc_band_checksum(band);	634	uint16_t chksum = ivi_calc_band_checksum(band);
635	if (chksum != band->checksum) {	635	if (chksum != band->checksum) {

libavcodec/interplayvideo.c+8−16

 #define PALETTE_COUNT 256
-/* debugging support */
-#define DEBUG_INTERPLAY 0
-#if DEBUG_INTERPLAY
-#define debug_interplay(x,...) av_log(NULL, AV_LOG_DEBUG, x, __VA_ARGS__)
-#else
-static inline void debug_interplay(const char *format, ...) { }
-#endif
 typedef struct IpvideoContext {
     AVCodecContext *avctx;
         y =   8 + ((B - 56) / 29);
     }
-    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
+    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
     return copy_from(s, &s->second_last_frame, x, y);
 }
         y = -(  8 + ((B - 56) / 29));
     }
-    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
+    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
     return copy_from(s, &s->current_frame, x, y);
 }
     x = -8 + BL;
     y = -8 + BH;
-    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
+    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
     return copy_from(s, &s->last_frame, x, y);
 }
     x = *s->stream_ptr++;
     y = *s->stream_ptr++;
-    debug_interplay ("    motion bytes = %d, %d\n", x, y);
+    av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
     return copy_from(s, &s->last_frame, x, y);
 }
     x = *s->stream_ptr++;
     y = *s->stream_ptr++;
-    debug_interplay ("    motion bytes = %d, %d\n", x, y);
+    av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
     return copy_from(s, &s->second_last_frame, x, y);
 }
     static int frame = 0;
     GetBitContext gb;
-    debug_interplay("------------------ frame %d\n", frame);
+    av_dlog(NULL, "------------------ frame %d\n", frame);
     frame++;
     if (!s->is_16bpp) {
         for (x = 0; x < s->avctx->width; x += 8) {
             opcode = get_bits(&gb, 4);
-            debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
+            av_dlog(NULL, "  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
-                            x, y, opcode, s->stream_ptr);
+                    x, y, opcode, s->stream_ptr);
             if (!s->is_16bpp) {
                 s->pixel_ptr = s->current_frame.data[0] + x

libavcodec/ituh263dec.c+3−3

@@ -152,7 +152,7 @@ int ff_h263_decode_mba(MpegEncContext *s) · 151 unmodified lines
152	*/	152	*/
153	static int h263_decode_gob_header(MpegEncContext *s)	153	static int h263_decode_gob_header(MpegEncContext *s)
154	{	154	{
155	unsigned int val, gfid, gob_number;	155	unsigned int val, gob_number;
156	int left;	156	int left;
157		157
158	/* Check for GOB Start Code */	158	/* Check for GOB Start Code */
@@ -183,12 +183,12 @@ static int h263_decode_gob_header(MpegEncContext *s) · 24 unmodified lines
183	s->qscale = get_bits(&s->gb, 5); /* SQUANT */	183	s->qscale = get_bits(&s->gb, 5); /* SQUANT */
184	if(get_bits1(&s->gb)==0)	184	if(get_bits1(&s->gb)==0)
185	return -1;	185	return -1;
186	gfid = get_bits(&s->gb, 2); /* GFID */	186	skip_bits(&s->gb, 2); /* GFID */
187	}else{	187	}else{
188	gob_number = get_bits(&s->gb, 5); /* GN */	188	gob_number = get_bits(&s->gb, 5); /* GN */
189	s->mb_x= 0;	189	s->mb_x= 0;
190	s->mb_y= s->gob_index* gob_number;	190	s->mb_y= s->gob_index* gob_number;
191	gfid = get_bits(&s->gb, 2); /* GFID */	191	skip_bits(&s->gb, 2); /* GFID */
192	s->qscale = get_bits(&s->gb, 5); /* GQUANT */	192	s->qscale = get_bits(&s->gb, 5); /* GQUANT */
193	}	193	}
194		194

libavcodec/ivi_common.c+3−3

@@ -418,8 +418,8 @@ int ff_ivi_decode_blocks(GetBitContext gb, IVIBandDesc band, IVITile *tile) · 417 unmodified lines
418	break;	418	break;
419	pos = band->scan[scan_pos];	419	pos = band->scan[scan_pos];
420		420
421	if (IVI_DEBUG && !val)	421	if (!val)
422	av_log(NULL, AV_LOG_ERROR, "Val = 0 encountered!\n");	422	av_dlog(NULL, "Val = 0 encountered!\n");
423		423
424	q = (base_tab[pos] * quant) >> 9;	424	q = (base_tab[pos] * quant) >> 9;
425	if (q > 1)	425	if (q > 1)
@@ -563,7 +563,7 @@ void ff_ivi_process_empty_tile(AVCodecContext avctx, IVIBandDesc band, · 137 unmodified lines
563	}	563	}
564		564
565		565
566	#if IVI_DEBUG	566	#ifdef DEBUG
567	uint16_t ivi_calc_band_checksum (IVIBandDesc *band)	567	uint16_t ivi_calc_band_checksum (IVIBandDesc *band)
568	{	568	{
569	int x, y;	569	int x, y;

libavcodec/ivi_common.h+0−4

 #include "get_bits.h"
 #include <stdint.h>
-#define IVI_DEBUG 0
 #define IVI_VLC_BITS 13 ///< max number of bits of the ivi's huffman codes
 /**
  */
 void ff_ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, int dst_pitch);
-#if IVI_DEBUG
 /**
  *  Calculate band checksum from band data.
  */
  *  Verify that band data lies in range.
  */
 int ivi_check_band (IVIBandDesc *band, const uint8_t *ref, int pitch);
-#endif
 #endif /* AVCODEC_IVI_COMMON_H */

libavcodec/mpeg12.c+5−6

         *s->current_picture_ptr->pan_scan= s1->pan_scan;
-        if (HAVE_PTHREADS && avctx->active_thread_type&FF_THREAD_FRAME)
+        if (HAVE_PTHREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
             ff_thread_finish_setup(avctx);
     }else{ //second field
             int i;
             *pict= *(AVFrame*)s->current_picture_ptr;
             ff_print_debug_info(s, pict);
         } else {
-            if (avctx->active_thread_type&FF_THREAD_FRAME)
+            if (avctx->active_thread_type & FF_THREAD_FRAME)
                 s->picture_number++;
             /* latency of 1 frame for I- and P-frames */
             /* XXX: use another variable than picture_number */
     Mpeg1Context *s1 = avctx->priv_data;
     MpegEncContext *s = &s1->mpeg_enc_ctx;
-    int drop_frame_flag;
     int time_code_hours, time_code_minutes;
     int time_code_seconds, time_code_pictures;
     int broken_link;
     init_get_bits(&s->gb, buf, buf_size*8);
-    drop_frame_flag = get_bits1(&s->gb);
+    skip_bits1(&s->gb); /* drop_frame_flag */
     time_code_hours=get_bits(&s->gb,5);
     time_code_minutes = get_bits(&s->gb,6);
         buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
         if (start_code > 0x1ff){
             if(s2->pict_type != AV_PICTURE_TYPE_B || avctx->skip_frame <= AVDISCARD_DEFAULT){
-                if(HAVE_THREADS && avctx->active_thread_type&FF_THREAD_SLICE){
+                if(HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE)){
                     int i;
                     assert(avctx->thread_count > 1);
                     break;
                 }
-                if(HAVE_THREADS && avctx->active_thread_type&FF_THREAD_SLICE){
+                if(HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE)){
                     int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
                     assert(avctx->thread_count > 1);
                     if(threshold <= mb_y){

libavcodec/mpeg12enc.c+1−2

@@ -761,10 +761,9 @@ void ff_mpeg1_encode_init(MpegEncContext *s) · 760 unmodified lines
761		761
762	if(mv==0) len= ff_mpeg12_mbMotionVectorTable[0][1];	762	if(mv==0) len= ff_mpeg12_mbMotionVectorTable[0][1];
763	else{	763	else{
764	int val, bit_size, range, code;	764	int val, bit_size, code;
765		765
766	bit_size = f_code - 1;	766	bit_size = f_code - 1;
767	range = 1 << bit_size;
768		767
769	val=mv;	768	val=mv;
770	if (val < 0)	769	if (val < 0)

libavcodec/mpeg4videodec.c+7−12

         header_extension= get_bits1(&s->gb);
     }
     if(header_extension){
-        int time_increment;
         int time_incr=0;
         while (get_bits1(&s->gb) != 0)
             time_incr++;
         check_marker(&s->gb, "before time_increment in video packed header");
-        time_increment= get_bits(&s->gb, s->time_increment_bits);
+        skip_bits(&s->gb, s->time_increment_bits); /* time_increment */
         check_marker(&s->gb, "before vop_coding_type in video packed header");
         skip_bits(&s->gb, 2); /* vop coding type */
         if (s->scalability) {
             GetBitContext bak= *gb;
-            int ref_layer_id;
-            int ref_layer_sampling_dir;
             int h_sampling_factor_n;
             int h_sampling_factor_m;
             int v_sampling_factor_n;
             int v_sampling_factor_m;
             s->hierachy_type= get_bits1(gb);
-            ref_layer_id= get_bits(gb, 4);
+            skip_bits(gb, 4);  /* ref_layer_id */
-            ref_layer_sampling_dir= get_bits1(gb);
+            skip_bits1(gb);    /* ref_layer_sampling_dir */
             h_sampling_factor_n= get_bits(gb, 5);
             h_sampling_factor_m= get_bits(gb, 5);
             v_sampling_factor_n= get_bits(gb, 5);
      if (s->shape != RECT_SHAPE) {
          if (s->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
-             int width, height, hor_spat_ref, ver_spat_ref;
+             skip_bits(gb, 13); /* width */
-             width = get_bits(gb, 13);
              skip_bits1(gb);   /* marker */
-             height = get_bits(gb, 13);
+             skip_bits(gb, 13); /* height */
              skip_bits1(gb);   /* marker */
-             hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
+             skip_bits(gb, 13); /* hor_spat_ref */
              skip_bits1(gb);   /* marker */
-             ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
+             skip_bits(gb, 13); /* ver_spat_ref */
          }
          skip_bits1(gb); /* change_CR_disable */

libavcodec/mpegvideo.c+5−3

@@ -527,7 +527,7 @@ int ff_mpeg_update_thread_context(AVCodecContext dst, const AVCodecContext src · 526 unmodified lines
527	s->last_pict_type= s1->pict_type;	527	s->last_pict_type= s1->pict_type;
528	if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->quality;	528	if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->quality;
529		529
530	if(s1->pict_type!=AV_PICTURE_TYPE_B){	530	if(s1->pict_type!=FF_B_TYPE){
531	s->last_non_b_pict_type= s1->pict_type;	531	s->last_non_b_pict_type= s1->pict_type;
532	}	532	}
533	}	533	}
@@ -586,7 +586,8 @@ av_cold int MPV_common_init(MpegEncContext *s) · 52 unmodified lines
586	return -1;	586	return -1;
587	}	587	}
588		588
589	if(s->avctx->active_thread_type&FF_THREAD_SLICE &&	589
		590	if((s->avctx->active_thread_type & FF_THREAD_SLICE) &&
590	(s->avctx->thread_count > MAX_THREADS \|\| (s->avctx->thread_count > s->mb_height && s->mb_height))){	591	(s->avctx->thread_count > MAX_THREADS \|\| (s->avctx->thread_count > s->mb_height && s->mb_height))){
591	av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");	592	av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
592	return -1;	593	return -1;
@@ -763,6 +764,7 @@ av_cold int MPV_common_init(MpegEncContext *s) · 170 unmodified lines
763	if(init_duplicate_context(s, s) < 0) goto fail;	764	if(init_duplicate_context(s, s) < 0) goto fail;
764	s->start_mb_y = 0;	765	s->start_mb_y = 0;
765	s->end_mb_y = s->mb_height;	766	s->end_mb_y = s->mb_height;
		767
766	}	768	}
767		769
768	return 0;	770	return 0;
@@ -2634,6 +2636,6 @@ void ff_set_qscale(MpegEncContext * s, int qscale) · 1865 unmodified lines
2634		2636
2635	void MPV_report_decode_progress(MpegEncContext *s)	2637	void MPV_report_decode_progress(MpegEncContext *s)
2636	{	2638	{
2637	if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame)	2639	if (s->pict_type != FF_B_TYPE && !s->partitioned_frame && !s->error_occurred)
2638	ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);	2640	ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2639	}	2641	}

libavcodec/mpegvideo.h+1−1

@@ -474,7 +474,7 @@ typedef struct MpegEncContext { · 473 unmodified lines
474	int last_bits; ///< temp var used for calculating the above vars	474	int last_bits; ///< temp var used for calculating the above vars
475		475
476	/* error concealment / resync */	476	/* error concealment / resync */
477	int error_count;	477	int error_count, error_occurred;
478	uint8_t *error_status_table; ///< table of the error status of each MB	478	uint8_t *error_status_table; ///< table of the error status of each MB
479	#define VP_START 1 ///< current MB is the first after a resync marker	479	#define VP_START 1 ///< current MB is the first after a resync marker
480	#define AC_ERROR 2	480	#define AC_ERROR 2

libavcodec/mpegvideo_enc.c+1−1

@@ -2759,7 +2759,7 @@ static int encode_picture(MpegEncContext *s, int picture_number) · 2758 unmodified lines
2759	{	2759	{
2760	int i;	2760	int i;
2761	int bits;	2761	int bits;
2762	int context_count = s->avctx->active_thread_type&FF_THREAD_SLICE ? s->avctx->thread_count : 1;	2762	int context_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;
2763		2763
2764	s->picture_number = picture_number;	2764	s->picture_number = picture_number;
2765		2765

libavcodec/mpegvideo_parser.c+1−2

     uint32_t start_code;
     int frame_rate_index, ext_type, bytes_left;
     int frame_rate_ext_n, frame_rate_ext_d;
-    int picture_structure, top_field_first, repeat_first_field, progressive_frame;
+    int top_field_first, repeat_first_field, progressive_frame;
     int horiz_size_ext, vert_size_ext, bit_rate_ext;
     int did_set_size=0;
 //FIXME replace the crap with get_bits()
                     break;
                 case 0x8: /* picture coding extension */
                     if (bytes_left >= 5) {
-                        picture_structure = buf[2]&3;
                         top_field_first = buf[3] & (1 << 7);
                         repeat_first_field = buf[3] & (1 << 1);
                         progressive_frame = buf[4] & (1 << 7);

libavcodec/msmpeg4.c+1−3

     /* the alt_bitstream reader could read over the end so we need to check it */
     if(left>=length && left<length+8)
     {
-        int fps;
+        skip_bits(&s->gb, 5); /* fps */
-        fps= get_bits(&s->gb, 5);
         s->bit_rate= get_bits(&s->gb, 11)*1024;
         if(s->msmpeg4_version>=3)
             s->flipflop_rounding= get_bits1(&s->gb);

libavcodec/pngdec.c+6−7

     AVFrame *p;
     uint8_t *crow_buf_base = NULL;
     uint32_t tag, length;
-    int ret, crc;
+    int ret;
     FFSWAP(AVFrame *, s->current_picture, s->last_picture);
     avctx->coded_frame= s->current_picture;
             s->compression_type = *s->bytestream++;
             s->filter_type = *s->bytestream++;
             s->interlace_type = *s->bytestream++;
-            crc = bytestream_get_be32(&s->bytestream);
+            s->bytestream += 4; /* crc */
             s->state |= PNG_IHDR;
             av_dlog(avctx, "width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
                     s->width, s->height, s->bit_depth, s->color_type,
             s->state |= PNG_IDAT;
             if (png_decode_idat(s, length) < 0)
                 goto fail;
-            /* skip crc */
+            s->bytestream += 4; /* crc */
-            crc = bytestream_get_be32(&s->bytestream);
             break;
         case MKTAG('P', 'L', 'T', 'E'):
             {
                     s->palette[i] = (0xff << 24);
                 }
                 s->state |= PNG_PLTE;
-                crc = bytestream_get_be32(&s->bytestream);
+                s->bytestream += 4; /* crc */
             }
             break;
         case MKTAG('t', 'R', 'N', 'S'):
                     v = *s->bytestream++;
                     s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
                 }
-                crc = bytestream_get_be32(&s->bytestream);
+                s->bytestream += 4; /* crc */
             }
             break;
         case MKTAG('I', 'E', 'N', 'D'):
             if (!(s->state & PNG_ALLIMAGE))
                 goto fail;
-            crc = bytestream_get_be32(&s->bytestream);
+            s->bytestream += 4; /* crc */
             goto exit_loop;
         default:
             /* skip tag */

libavcodec/pthread.c+1−1

@@ -55,7 +55,7 @@ typedef struct ThreadContext { · 54 unmodified lines
55	} ThreadContext;	55	} ThreadContext;
56		56
57	/// Max number of frame buffers that can be allocated when using frame threads.	57	/// Max number of frame buffers that can be allocated when using frame threads.
58	#define MAX_BUFFERS 33	58	#define MAX_BUFFERS (32+1)
59		59
60	/**	60	/**
61	* Context used by codec threads and stored in their AVCodecContext thread_opaque.	61	* Context used by codec threads and stored in their AVCodecContext thread_opaque.

libavcodec/rv10.c+2−2

@@ -235,7 +235,7 @@ int rv_decode_dc(MpegEncContext *s, int n) · 234 unmodified lines
235	/* read RV 1.0 compatible frame header */	235	/* read RV 1.0 compatible frame header */
236	static int rv10_decode_picture_header(MpegEncContext *s)	236	static int rv10_decode_picture_header(MpegEncContext *s)
237	{	237	{
238	int mb_count, pb_frame, marker, unk av_unused, mb_xy;	238	int mb_count, pb_frame, marker, mb_xy;
239		239
240	marker = get_bits1(&s->gb);	240	marker = get_bits1(&s->gb);
241		241
@@ -282,7 +282,7 @@ static int rv10_decode_picture_header(MpegEncContext *s) · 40 unmodified lines
282	s->mb_y = 0;	282	s->mb_y = 0;
283	mb_count = s->mb_width * s->mb_height;	283	mb_count = s->mb_width * s->mb_height;
284	}	284	}
285	unk= get_bits(&s->gb, 3); /* ignored */	285	skip_bits(&s->gb, 3); /* ignored */
286	s->f_code = 1;	286	s->f_code = 1;
287	s->unrestricted_mv = 1;	287	s->unrestricted_mv = 1;
288		288

libavcodec/s302m.c+1−2

                                     int buf_size)
 {
     uint32_t h;
-    int frame_size, channels, id av_unused, bits;
+    int frame_size, channels, bits;
     if (buf_size <= AES3_HEADER_LEN) {
         av_log(avctx, AV_LOG_ERROR, "frame is too short\n");
     h = AV_RB32(buf);
     frame_size =  (h >> 16) & 0xffff;
     channels   = ((h >> 14) & 0x0003) * 2 +  2;
-    id         =  (h >>  6) & 0x00ff;
     bits       = ((h >>  4) & 0x0003) * 4 + 16;
     if (AES3_HEADER_LEN + frame_size != buf_size || bits > 24) {

libavcodec/shorten.c+1−2

 {
     GetBitContext hb;
     int len;
-    int chunk_size av_unused;
     short wave_format;
     init_get_bits(&hb, header, header_size*8);
         return -1;
     }
-    chunk_size = get_le32(&hb);
+    skip_bits_long(&hb, 32);    /* chunk_size */
     if (get_le32(&hb) != MKTAG('W','A','V','E')) {
         av_log(avctx, AV_LOG_ERROR, "missing WAVE tag\n");

libavcodec/svq1dec.c+11−23

  */
-//#define DEBUG_SVQ1
 #include "avcodec.h"
 #include "dsputil.h"
 #include "mpegvideo.h"
     }
     if ((stages > 0) && (level >= 4)) {
-#ifdef DEBUG_SVQ1
+      av_dlog(NULL,
-    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
+              "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
-#endif
+              stages, level);
       return -1;        /* invalid vector */
     }
     if (stages == -1) continue; /* skip vector */
     if ((stages > 0) && (level >= 4)) {
-#ifdef DEBUG_SVQ1
+      av_dlog(NULL,
-    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
+              "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
-#endif
+              stages, level);
       return -1;        /* invalid vector */
     }
     if (result != 0)
     {
-#ifdef DEBUG_SVQ1
+      av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
-    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
-#endif
       break;
     }
     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
     if (result != 0)
     {
-#ifdef DEBUG_SVQ1
+      av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
-    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
-#endif
       break;
     }
     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
   int frame_size_code;
-  int temporal_reference;
-  temporal_reference = get_bits (bitbuf, 8);
+  skip_bits(bitbuf, 8); /* temporal_reference */
   /* frame type */
   s->pict_type= get_bits (bitbuf, 2)+1;
   if (result != 0)
   {
-#ifdef DEBUG_SVQ1
+    av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
-    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
-#endif
     return result;
   }
           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
           if (result != 0)
           {
-//#ifdef DEBUG_SVQ1
             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
-//#endif
             goto err;
           }
         }
                                             linesize, pmv, x, y);
           if (result != 0)
           {
-#ifdef DEBUG_SVQ1
+            av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
-    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
-#endif
             goto err;
           }
         }

libavcodec/targa.c+4−3

     AVFrame * const p= (AVFrame*)&s->picture;
     uint8_t *dst;
     int stride;
-    int idlen, pal, compr, x, y, w, h, bpp, flags;
+    int idlen, compr, y, w, h, bpp, flags;
     int first_clr, colors, csize;
     /* parse image header */
     CHECK_BUFFER_SIZE(buf, buf_end, 18, "header");
     idlen = *buf++;
-    pal = *buf++;
+    buf++; /* pal */
     compr = *buf++;
     first_clr = AV_RL16(buf); buf += 2;
     colors = AV_RL16(buf); buf += 2;
     csize = *buf++;
-    x = AV_RL16(buf); buf += 2;
+    buf += 2; /* x */
     y = AV_RL16(buf); buf += 2;
     w = AV_RL16(buf); buf += 2;
     h = AV_RL16(buf); buf += 2;
             CHECK_BUFFER_SIZE(buf, buf_end, img_size, "image data");
             for(y = 0; y < s->height; y++){
 #if HAVE_BIGENDIAN
+                int x;
                 if((s->bpp + 1) >> 3 == 2){
                     uint16_t *dst16 = (uint16_t*)dst;
                     for(x = 0; x < s->width; x++)

libavcodec/truemotion2.c+0−13

@@ -211,19 +211,6 @@ static inline int tm2_read_header(TM2Context ctx, const uint8_t buf) · 210 unmodified lines
211	/* av_log (ctx->avctx, AV_LOG_ERROR, "TM2 old header: not implemented (yet)\n"); */	211	/* av_log (ctx->avctx, AV_LOG_ERROR, "TM2 old header: not implemented (yet)\n"); */
212	return 40;	212	return 40;
213	} else if(magic == 0x00000101) { /* new header */	213	} else if(magic == 0x00000101) { /* new header */
214	av_unused int w, h, size, flags, xr, yr, length;
215
216	length = AV_RL32(buf);
217	buf += 4;
218
219	init_get_bits(&ctx->gb, buf, 32 * 8);
220	size = get_bits_long(&ctx->gb, 31);
221	h = get_bits(&ctx->gb, 15);
222	w = get_bits(&ctx->gb, 15);
223	flags = get_bits_long(&ctx->gb, 31);
224	yr = get_bits(&ctx->gb, 9);
225	xr = get_bits(&ctx->gb, 9);
226
227	return 40;	214	return 40;
228	} else {	215	} else {
229	av_log (ctx->avctx, AV_LOG_ERROR, "Not a TM2 header: 0x%08X\n", magic);	216	av_log (ctx->avctx, AV_LOG_ERROR, "Not a TM2 header: 0x%08X\n", magic);

libavcodec/tscc.c+0−3

     int buf_size = avpkt->size;
     CamtasiaContext * const c = avctx->priv_data;
     const unsigned char *encoded = buf;
-    unsigned char *outptr;
     int zret; // Zlib return code
     int len = buf_size;
         return -1;
     }
-    outptr = c->pic.data[0]; // Output image pointer
     zret = inflateReset(&(c->zstream));
     if (zret != Z_OK) {
         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);

libavcodec/utils.c+1−1

@@ -115,7 +115,7 @@ typedef struct InternalBuffer{ · 114 unmodified lines
115	enum PixelFormat pix_fmt;	115	enum PixelFormat pix_fmt;
116	}InternalBuffer;	116	}InternalBuffer;
117		117
118	#define INTERNAL_BUFFER_SIZE 33	118	#define INTERNAL_BUFFER_SIZE (32+1)
119		119
120	void avcodec_align_dimensions2(AVCodecContext s, int width, int *height, int linesize_align[4]){	120	void avcodec_align_dimensions2(AVCodecContext s, int width, int *height, int linesize_align[4]){
121	int w_align= 1;	121	int w_align= 1;

libavcodec/vorbis.c+3−6

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
-#undef V_DEBUG
-//#define V_DEBUG
 #define ALT_BITSTREAM_READER_LE
 #include "avcodec.h"
 #include "get_bits.h"
     unsigned i, j, p, code;
-#ifdef V_DEBUG
+#ifdef DEBUG
     GetBitContext gb;
 #endif
     for (i = 0; i < bits[p]; ++i)
         exit_at_level[i+1] = 1 << i;
-#ifdef V_DEBUG
+#ifdef DEBUG
     av_log(NULL, AV_LOG_INFO, " %u. of %u code len %d code %d - ", p, num, bits[p], codes[p]);
     init_get_bits(&gb, (uint8_t *)&codes[p], bits[p]);
     for (i = 0; i < bits[p]; ++i)
             exit_at_level[j] = code + (1 << (j - 1));
         codes[p] = code;
-#ifdef V_DEBUG
+#ifdef DEBUG
         av_log(NULL, AV_LOG_INFO, " %d. code len %d code %d - ", p, bits[p], codes[p]);
         init_get_bits(&gb, (uint8_t *)&codes[p], bits[p]);
         for (i = 0; i < bits[p]; ++i)

libavcodec/vorbisdec.c+106−110

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
-#undef V_DEBUG
-//#define V_DEBUG
-//#define AV_DEBUG(...) av_log(NULL, AV_LOG_INFO, __VA_ARGS__)
 #include <math.h>
 #define ALT_BITSTREAM_READER_LE
 #define V_MAX_VLCS (1 << 16)
 #define V_MAX_PARTITIONS (1 << 20)
-#ifndef V_DEBUG
-#define AV_DEBUG(...)
-#endif
 #undef NDEBUG
 #include <assert.h>
     vc->codebook_count = get_bits(gb, 8) + 1;
-    AV_DEBUG(" Codebooks: %d \n", vc->codebook_count);
+    av_dlog(NULL, " Codebooks: %d \n", vc->codebook_count);
     vc->codebooks = av_mallocz(vc->codebook_count * sizeof(*vc->codebooks));
     tmp_vlc_bits  = av_mallocz(V_MAX_VLCS * sizeof(*tmp_vlc_bits));
         vorbis_codebook *codebook_setup = &vc->codebooks[cb];
         unsigned ordered, t, entries, used_entries = 0;
-        AV_DEBUG(" %u. Codebook\n", cb);
+        av_dlog(NULL, " %u. Codebook\n", cb);
         if (get_bits(gb, 24) != 0x564342) {
             av_log(vc->avccontext, AV_LOG_ERROR,
         ordered = get_bits1(gb);
-        AV_DEBUG(" codebook_dimensions %d, codebook_entries %u\n",
+        av_dlog(NULL, " codebook_dimensions %d, codebook_entries %u\n",
-                 codebook_setup->dimensions, entries);
+                codebook_setup->dimensions, entries);
         if (!ordered) {
             unsigned ce, flag;
             unsigned sparse = get_bits1(gb);
-            AV_DEBUG(" not ordered \n");
+            av_dlog(NULL, " not ordered \n");
             if (sparse) {
-                AV_DEBUG(" sparse \n");
+                av_dlog(NULL, " sparse \n");
                 used_entries = 0;
                 for (ce = 0; ce < entries; ++ce) {
                         tmp_vlc_bits[ce] = 0;
                 }
             } else {
-                AV_DEBUG(" not sparse \n");
+                av_dlog(NULL, " not sparse \n");
                 used_entries = entries;
                 for (ce = 0; ce < entries; ++ce)
             unsigned current_entry  = 0;
             unsigned current_length = get_bits(gb, 5) + 1;
-            AV_DEBUG(" ordered, current length: %u\n", current_length);  //FIXME
+            av_dlog(NULL, " ordered, current length: %u\n", current_length);  //FIXME
             used_entries = entries;
             for (; current_entry < used_entries && current_length <= 32; ++current_length) {
                 unsigned i, number;
-                AV_DEBUG(" number bits: %u ", ilog(entries - current_entry));
+                av_dlog(NULL, " number bits: %u ", ilog(entries - current_entry));
                 number = get_bits(gb, ilog(entries - current_entry));
-                AV_DEBUG(" number: %u\n", number);
+                av_dlog(NULL, " number: %u\n", number);
                 for (i = current_entry; i < number+current_entry; ++i)
                     if (i < used_entries)
         codebook_setup->lookup_type = get_bits(gb, 4);
-        AV_DEBUG(" lookup type: %d : %s \n", codebook_setup->lookup_type, codebook_setup->lookup_type ? "vq" : "no lookup");
+        av_dlog(NULL, " lookup type: %d : %s \n", codebook_setup->lookup_type,
+                codebook_setup->lookup_type ? "vq" : "no lookup");
 // If the codebook is used for (inverse) VQ, calculate codevectors.
             unsigned codebook_value_bits = get_bits(gb, 4) + 1;
             unsigned codebook_sequence_p = get_bits1(gb);
-            AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values);
+            av_dlog(NULL, " We expect %d numbers for building the codevectors. \n",
-            AV_DEBUG("  delta %f minmum %f \n", codebook_delta_value, codebook_minimum_value);
+                    codebook_lookup_values);
+            av_dlog(NULL, "  delta %f minmum %f \n",
+                    codebook_delta_value, codebook_minimum_value);
             for (i = 0; i < codebook_lookup_values; ++i) {
                 codebook_multiplicands[i] = get_bits(gb, codebook_value_bits);
-                AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands[i]*codebook_delta_value+codebook_minimum_value);
+                av_dlog(NULL, " multiplicands*delta+minmum : %e \n",
-                AV_DEBUG(" multiplicand %u\n", codebook_multiplicands[i]);
+                        (float)codebook_multiplicands[i] * codebook_delta_value + codebook_minimum_value);
+                av_dlog(NULL, " multiplicand %u\n", codebook_multiplicands[i]);
             }
 // Weed out unused vlcs and build codevector vector
                     float last = 0.0;
                     unsigned lookup_offset = i;
-#ifdef V_DEBUG
+                    av_dlog(vc->avccontext, "Lookup offset %u ,", i);
-                    av_log(vc->avccontext, AV_LOG_INFO, "Lookup offset %u ,", i);
-#endif
                     for (k = 0; k < dim; ++k) {
                         unsigned multiplicand_offset = lookup_offset % codebook_lookup_values;
                     }
                     tmp_vlc_bits[j] = tmp_vlc_bits[i];
-#ifdef V_DEBUG
+                    av_dlog(vc->avccontext, "real lookup offset %u, vector: ", j);
-                    av_log(vc->avccontext, AV_LOG_INFO, "real lookup offset %u, vector: ", j);
                     for (k = 0; k < dim; ++k)
-                        av_log(vc->avccontext, AV_LOG_INFO, " %f ", codebook_setup->codevectors[j * dim + k]);
+                        av_dlog(vc->avccontext, " %f ",
-                    av_log(vc->avccontext, AV_LOG_INFO, "\n");
+                                codebook_setup->codevectors[j * dim + k]);
-#endif
+                    av_dlog(vc->avccontext, "\n");
                     ++j;
                 }
     for (i = 0; i < vorbis_time_count; ++i) {
         unsigned vorbis_tdtransform = get_bits(gb, 16);
-        AV_DEBUG(" Vorbis time domain transform %u: %u\n",
+        av_dlog(NULL, " Vorbis time domain transform %u: %u\n",
-                 vorbis_time_count, vorbis_tdtransform);
+                vorbis_time_count, vorbis_tdtransform);
         if (vorbis_tdtransform) {
             av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
         floor_setup->floor_type = get_bits(gb, 16);
-        AV_DEBUG(" %d. floor type %d \n", i, floor_setup->floor_type);
+        av_dlog(NULL, " %d. floor type %d \n", i, floor_setup->floor_type);
         if (floor_setup->floor_type == 1) {
             int maximum_class = -1;
             floor_setup->data.t1.partitions = get_bits(gb, 5);
-            AV_DEBUG(" %d.floor: %d partitions \n", i, floor_setup->data.t1.partitions);
+            av_dlog(NULL, " %d.floor: %d partitions \n",
+                    i, floor_setup->data.t1.partitions);
             for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
                 floor_setup->data.t1.partition_class[j] = get_bits(gb, 4);
                 if (floor_setup->data.t1.partition_class[j] > maximum_class)
                     maximum_class = floor_setup->data.t1.partition_class[j];
-                AV_DEBUG(" %d. floor %d partition class %d \n", i, j, floor_setup->data.t1.partition_class[j]);
+                av_dlog(NULL, " %d. floor %d partition class %d \n",
+                        i, j, floor_setup->data.t1.partition_class[j]);
             }
-            AV_DEBUG(" maximum class %d \n", maximum_class);
+            av_dlog(NULL, " maximum class %d \n", maximum_class);
             for (j = 0; j <= maximum_class; ++j) {
                 floor_setup->data.t1.class_dimensions[j] = get_bits(gb, 3) + 1;
                 floor_setup->data.t1.class_subclasses[j] = get_bits(gb, 2);
-                AV_DEBUG(" %d floor %d class dim: %d subclasses %d \n", i, j, floor_setup->data.t1.class_dimensions[j], floor_setup->data.t1.class_subclasses[j]);
+                av_dlog(NULL, " %d floor %d class dim: %d subclasses %d \n", i, j,
+                        floor_setup->data.t1.class_dimensions[j],
+                        floor_setup->data.t1.class_subclasses[j]);
                 if (floor_setup->data.t1.class_subclasses[j]) {
                     GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count)
-                    AV_DEBUG("   masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);
+                    av_dlog(NULL, "   masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);
                 }
                 for (k = 0; k < (1 << floor_setup->data.t1.class_subclasses[j]); ++k) {
                         VALIDATE_INDEX(bits, vc->codebook_count)
                     floor_setup->data.t1.subclass_books[j][k] = bits;
-                    AV_DEBUG("    book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);
+                    av_dlog(NULL, "    book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);
                 }
             }
                 for (k = 0; k < floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]]; ++k, ++floor1_values) {
                     floor_setup->data.t1.list[floor1_values].x = get_bits(gb, rangebits);
-                    AV_DEBUG(" %u. floor1 Y coord. %d\n", floor1_values,
+                    av_dlog(NULL, " %u. floor1 Y coord. %d\n", floor1_values,
-                             floor_setup->data.t1.list[floor1_values].x);
+                            floor_setup->data.t1.list[floor1_values].x);
                 }
             }
             if (!floor_setup->data.t0.lsp)
                 return -1;
-#ifdef V_DEBUG /* debug output parsed headers */
+            /* debug output parsed headers */
-            AV_DEBUG("floor0 order: %u\n", floor_setup->data.t0.order);
+            av_dlog(NULL, "floor0 order: %u\n", floor_setup->data.t0.order);
-            AV_DEBUG("floor0 rate: %u\n", floor_setup->data.t0.rate);
+            av_dlog(NULL, "floor0 rate: %u\n", floor_setup->data.t0.rate);
-            AV_DEBUG("floor0 bark map size: %u\n",
+            av_dlog(NULL, "floor0 bark map size: %u\n",
-                     floor_setup->data.t0.bark_map_size);
+                    floor_setup->data.t0.bark_map_size);
-            AV_DEBUG("floor0 amplitude bits: %u\n",
+            av_dlog(NULL, "floor0 amplitude bits: %u\n",
-                     floor_setup->data.t0.amplitude_bits);
+                    floor_setup->data.t0.amplitude_bits);
-            AV_DEBUG("floor0 amplitude offset: %u\n",
+            av_dlog(NULL, "floor0 amplitude offset: %u\n",
-                     floor_setup->data.t0.amplitude_offset);
+                    floor_setup->data.t0.amplitude_offset);
-            AV_DEBUG("floor0 number of books: %u\n",
+            av_dlog(NULL, "floor0 number of books: %u\n",
-                     floor_setup->data.t0.num_books);
+                    floor_setup->data.t0.num_books);
-            AV_DEBUG("floor0 book list pointer: %p\n",
+            av_dlog(NULL, "floor0 book list pointer: %p\n",
-                     floor_setup->data.t0.book_list);
+                    floor_setup->data.t0.book_list);
             {
                 int idx;
                 for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {
-                    AV_DEBUG("  Book %d: %u\n",
+                    av_dlog(NULL, "  Book %d: %u\n", idx + 1,
-                             idx+1,
+                            floor_setup->data.t0.book_list[idx]);
-                             floor_setup->data.t0.book_list[idx]);
                 }
             }
-#endif
         } else {
             av_log(vc->avccontext, AV_LOG_ERROR, "Invalid floor type!\n");
             return -1;
     vc->residue_count = get_bits(gb, 6)+1;
     vc->residues      = av_mallocz(vc->residue_count * sizeof(*vc->residues));
-    AV_DEBUG(" There are %d residues. \n", vc->residue_count);
+    av_dlog(NULL, " There are %d residues. \n", vc->residue_count);
     for (i = 0; i < vc->residue_count; ++i) {
         vorbis_residue *res_setup = &vc->residues[i];
         res_setup->type = get_bits(gb, 16);
-        AV_DEBUG(" %u. residue type %d\n", i, res_setup->type);
+        av_dlog(NULL, " %u. residue type %d\n", i, res_setup->type);
         res_setup->begin          = get_bits(gb, 24);
         res_setup->end            = get_bits(gb, 24);
         if (!res_setup->classifs)
             return AVERROR(ENOMEM);
-        AV_DEBUG("    begin %d end %d part.size %d classif.s %d classbook %d \n", res_setup->begin, res_setup->end, res_setup->partition_size,
+        av_dlog(NULL, "    begin %d end %d part.size %d classif.s %d classbook %d \n",
-          res_setup->classifications, res_setup->classbook);
+                res_setup->begin, res_setup->end, res_setup->partition_size,
+                res_setup->classifications, res_setup->classbook);
         for (j = 0; j < res_setup->classifications; ++j) {
             high_bits = 0;
                 high_bits = get_bits(gb, 5);
             cascade[j] = (high_bits << 3) + low_bits;
-            AV_DEBUG("     %u class cascade depth: %d\n", j, ilog(cascade[j]));
+            av_dlog(NULL, "     %u class cascade depth: %d\n", j, ilog(cascade[j]));
         }
         res_setup->maxpass = 0;
                 if (cascade[j]&(1 << k)) {
                     GET_VALIDATED_INDEX(res_setup->books[j][k], 8, vc->codebook_count)
-                    AV_DEBUG("     %u class cascade depth %u book: %d\n",
+                    av_dlog(NULL, "     %u class cascade depth %u book: %d\n",
-                             j, k, res_setup->books[j][k]);
+                            j, k, res_setup->books[j][k]);
                     if (k>res_setup->maxpass)
                         res_setup->maxpass = k;
     vc->mapping_count = get_bits(gb, 6)+1;
     vc->mappings      = av_mallocz(vc->mapping_count * sizeof(*vc->mappings));
-    AV_DEBUG(" There are %d mappings. \n", vc->mapping_count);
+    av_dlog(NULL, " There are %d mappings. \n", vc->mapping_count);
     for (i = 0; i < vc->mapping_count; ++i) {
         vorbis_mapping *mapping_setup = &vc->mappings[i];
             mapping_setup->coupling_steps = 0;
         }
-        AV_DEBUG("   %u mapping coupling steps: %d\n",
+        av_dlog(NULL, "   %u mapping coupling steps: %d\n",
-                 i, mapping_setup->coupling_steps);
+                i, mapping_setup->coupling_steps);
         if (get_bits(gb, 2)) {
             av_log(vc->avccontext, AV_LOG_ERROR, "%u. mapping setup data invalid.\n", i);
             GET_VALIDATED_INDEX(mapping_setup->submap_floor[j],   8, vc->floor_count)
             GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8, vc->residue_count)
-            AV_DEBUG("   %u mapping %u submap : floor %d, residue %d\n",
+            av_dlog(NULL, "   %u mapping %u submap : floor %d, residue %d\n", i, j,
-                     i, j,
+                    mapping_setup->submap_floor[j],
-                     mapping_setup->submap_floor[j],
+                    mapping_setup->submap_residue[j]);
-                     mapping_setup->submap_residue[j]);
         }
     }
     return 0;
         vf->map_size[blockflag] = n;
     }
-#ifdef V_DEBUG
     for (idx = 0; idx <= n; ++idx) {
-        AV_DEBUG("floor0 map: map at pos %d is %d\n",
+        av_dlog(NULL, "floor0 map: map at pos %d is %d\n", idx, map[idx]);
-                 idx, map[idx]);
     }
-#endif
 }
 static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
     vc->mode_count = get_bits(gb, 6) + 1;
     vc->modes      = av_mallocz(vc->mode_count * sizeof(*vc->modes));
-    AV_DEBUG(" There are %d modes.\n", vc->mode_count);
+    av_dlog(NULL, " There are %d modes.\n", vc->mode_count);
     for (i = 0; i < vc->mode_count; ++i) {
         vorbis_mode *mode_setup = &vc->modes[i];
         mode_setup->transformtype = get_bits(gb, 16); //FIXME check
         GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count);
-        AV_DEBUG(" %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",
+        av_dlog(NULL, " %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",
-                 i, mode_setup->blockflag, mode_setup->windowtype,
+                i, mode_setup->blockflag, mode_setup->windowtype,
-                 mode_setup->transformtype, mode_setup->mapping);
+                mode_setup->transformtype, mode_setup->mapping);
     }
     return 0;
 }
     ff_mdct_init(&vc->mdct[0], bl0, 1, -vc->scale_bias);
     ff_mdct_init(&vc->mdct[1], bl1, 1, -vc->scale_bias);
-    AV_DEBUG(" vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
+    av_dlog(NULL, " vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
             vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
 /*
                     "floor0 dec: booknumber too high!\n");
             book_idx =  0;
         }
-        AV_DEBUG("floor0 dec: booknumber: %u\n", book_idx);
+        av_dlog(NULL, "floor0 dec: booknumber: %u\n", book_idx);
         codebook = vc->codebooks[vf->book_list[book_idx]];
         /* Invalid codebook! */
         if (!codebook.codevectors)
         while (lsp_len<vf->order) {
             int vec_off;
-            AV_DEBUG("floor0 dec: book dimension: %d\n", codebook.dimensions);
+            av_dlog(NULL, "floor0 dec: book dimension: %d\n", codebook.dimensions);
-            AV_DEBUG("floor0 dec: maximum depth: %d\n", codebook.maxdepth);
+            av_dlog(NULL, "floor0 dec: maximum depth: %d\n", codebook.maxdepth);
             /* read temp vector */
             vec_off = get_vlc2(&vc->gb, codebook.vlc.table,
                                codebook.nb_bits, codebook.maxdepth)
                       * codebook.dimensions;
-            AV_DEBUG("floor0 dec: vector offset: %d\n", vec_off);
+            av_dlog(NULL, "floor0 dec: vector offset: %d\n", vec_off);
             /* copy each vector component and add last to it */
             for (idx = 0; idx < codebook.dimensions; ++idx)
                 lsp[lsp_len+idx] = codebook.codevectors[vec_off+idx] + last;
             lsp_len += codebook.dimensions;
         }
-#ifdef V_DEBUG
         /* DEBUG: output lsp coeffs */
         {
             int idx;
             for (idx = 0; idx < lsp_len; ++idx)
-                AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);
+                av_dlog(NULL, "floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);
         }
-#endif
         /* synthesize floor output vector */
         {
             for (i = 0; i < order; i++)
                 lsp[i] = 2.0f * cos(lsp[i]);
-            AV_DEBUG("floor0 synth: map_size = %d; m = %d; wstep = %f\n",
-                     vf->map_size, order, wstep);
             i = 0;
             while (i < vf->map_size[blockflag]) {
                 int j, iter_cond = vf->map[blockflag][i];
         return 1;
     }
-    AV_DEBUG(" Floor0 decoded\n");
+    av_dlog(NULL, " Floor0 decoded\n");
     return 0;
 }
     floor1_Y[0] = get_bits(gb, ilog(range - 1));
     floor1_Y[1] = get_bits(gb, ilog(range - 1));
-    AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
+    av_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
     offset = 2;
     for (i = 0; i < vf->partitions; ++i) {
         csub = (1 << cbits) - 1;
         cval = 0;
-        AV_DEBUG("Cbits %u\n", cbits);
+        av_dlog(NULL, "Cbits %u\n", cbits);
         if (cbits) // this reads all subclasses for this partition's class
             cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
         for (j = 0; j < cdim; ++j) {
             book = vf->subclass_books[partition_class][cval & csub];
-            AV_DEBUG("book %d Cbits %u cval %u  bits:%d\n",
+            av_dlog(NULL, "book %d Cbits %u cval %u  bits:%d\n",
-                     book, cbits, cval, get_bits_count(gb));
+                    book, cbits, cval, get_bits_count(gb));
             cval = cval >> cbits;
             if (book > -1) {
                 floor1_Y[offset+j] = 0;
             }
-            AV_DEBUG(" floor(%d) = %d \n", vf->list[offset+j].x, floor1_Y[offset+j]);
+            av_dlog(NULL, " floor(%d) = %d \n",
+                    vf->list[offset+j].x, floor1_Y[offset+j]);
         }
         offset+=cdim;
     }
             floor1_Y_final[i] = predicted;
         }
-        AV_DEBUG(" Decoded floor(%d) = %u / val %u\n",
+        av_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",
-                 vf->list[i].x, floor1_Y_final[i], val);
+                vf->list[i].x, floor1_Y_final[i], val);
     }
 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
     ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);
-    AV_DEBUG(" Floor decoded\n");
+    av_dlog(NULL, " Floor decoded\n");
     return 0;
 }
         ch_used = ch;
     }
-    AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);
+    av_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);
     for (pass = 0; pass <= vr->maxpass; ++pass) { // FIXME OPTIMIZE?
         uint16_t voffset, partition_count, j_times_ptns_to_read;
                         unsigned temp = get_vlc2(gb, vc->codebooks[vr->classbook].vlc.table,
                                                  vc->codebooks[vr->classbook].nb_bits, 3);
-                        AV_DEBUG("Classword: %u\n", temp);
+                        av_dlog(NULL, "Classword: %u\n", temp);
                         assert(vr->classifications > 1 && temp <= 65536); //needed for inverse[]
                         for (i = 0; i < c_p_c; ++i) {
                                     for (l = 0; l < dim; ++l, ++voffs) {
                                         vec[voffs]+=codebook.codevectors[coffs+l];  // FPMATH
-                                        AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d  \n", pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
+                                        av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d  \n",
+                                                pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
                                     }
                                 }
                             } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) { // most frequent case optimized
                                         vec[voffs       ] += codebook.codevectors[coffs + l    ];  // FPMATH
                                         vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];  // FPMATH
-                                        AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n", pass, voffset / ch + (voffs % ch) * vlen, vec[voffset / ch + (voffs % ch) * vlen], codebook.codevectors[coffs + l], coffs, l);
+                                        av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n",
+                                                pass, voffset / ch + (voffs % ch) * vlen,
+                                                vec[voffset / ch + (voffs % ch) * vlen],
+                                                codebook.codevectors[coffs + l], coffs, l);
                                     }
                                 }
                                     for (l = 0; l < dim; ++l, ++voffs) {
                                         vec[voffs / ch + (voffs % ch) * vlen] += codebook.codevectors[coffs + l];  // FPMATH FIXME use if and counter instead of / and %
-                                        AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n", pass, voffset / ch + (voffs % ch) * vlen, vec[voffset / ch + (voffs % ch) * vlen], codebook.codevectors[coffs + l], coffs, l);
+                                        av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n",
+                                                pass, voffset / ch + (voffs % ch) * vlen,
+                                                vec[voffset / ch + (voffs % ch) * vlen],
+                                                codebook.codevectors[coffs + l], coffs, l);
                                     }
                                 }
                             }
     vc->mode_number = mode_number;
     mapping = &vc->mappings[vc->modes[mode_number].mapping];
-    AV_DEBUG(" Mode number: %u , mapping: %d , blocktype %d\n", mode_number,
+    av_dlog(NULL, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number,
-             vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
+            vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
     blockflag = vc->modes[mode_number].blockflag;
     blocksize = vc->blocksize[blockflag];
     if (!buf_size)
         return 0;
-    AV_DEBUG("packet length %d \n", buf_size);
+    av_dlog(NULL, "packet length %d \n", buf_size);
     init_get_bits(gb, buf, buf_size*8);
         return buf_size ;
     }
-    AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb)/8, get_bits_count(gb)%8, len);
+    av_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
+            get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);
     if (vc->audio_channels > 8) {
         for (i = 0; i < vc->audio_channels; i++)

libavcodec/vqavideo.c+6−14

 #define CPLZ_TAG MKBETAG('C', 'P', 'L', 'Z')
 #define VPTZ_TAG MKBETAG('V', 'P', 'T', 'Z')
-#define VQA_DEBUG 0
-#if VQA_DEBUG
-#define vqa_debug printf
-#else
-static inline void vqa_debug(const char *format, ...) { }
-#endif
 typedef struct VqaContext {
     AVCodecContext *avctx;
     while (src_index < src_size) {
-        vqa_debug("      opcode %02X: ", src[src_index]);
+        av_dlog(NULL, "      opcode %02X: ", src[src_index]);
         /* 0x80 means that frame is finished */
         if (src[src_index] == 0x80)
             src_index += 2;
             src_pos = AV_RL16(&src[src_index]);
             src_index += 2;
-            vqa_debug("(1) copy %X bytes from absolute pos %X\n", count, src_pos);
+            av_dlog(NULL, "(1) copy %X bytes from absolute pos %X\n", count, src_pos);
             CHECK_COUNT();
             for (i = 0; i < count; i++)
                 dest[dest_index + i] = dest[src_pos + i];
             count = AV_RL16(&src[src_index]);
             src_index += 2;
             color = src[src_index++];
-            vqa_debug("(2) set %X bytes to %02X\n", count, color);
+            av_dlog(NULL, "(2) set %X bytes to %02X\n", count, color);
             CHECK_COUNT();
             memset(&dest[dest_index], color, count);
             dest_index += count;
             count = (src[src_index++] & 0x3F) + 3;
             src_pos = AV_RL16(&src[src_index]);
             src_index += 2;
-            vqa_debug("(3) copy %X bytes from absolute pos %X\n", count, src_pos);
+            av_dlog(NULL, "(3) copy %X bytes from absolute pos %X\n", count, src_pos);
             CHECK_COUNT();
             for (i = 0; i < count; i++)
                 dest[dest_index + i] = dest[src_pos + i];
         } else if (src[src_index] > 0x80) {
             count = src[src_index++] & 0x3F;
-            vqa_debug("(4) copy %X bytes from source to dest\n", count);
+            av_dlog(NULL, "(4) copy %X bytes from source to dest\n", count);
             CHECK_COUNT();
             memcpy(&dest[dest_index], &src[src_index], count);
             src_index += count;
             count = ((src[src_index] & 0x70) >> 4) + 3;
             src_pos = AV_RB16(&src[src_index]) & 0x0FFF;
             src_index += 2;
-            vqa_debug("(5) copy %X bytes from relpos %X\n", count, src_pos);
+            av_dlog(NULL, "(5) copy %X bytes from relpos %X\n", count, src_pos);
             CHECK_COUNT();
             for (i = 0; i < count; i++)
                 dest[dest_index + i] = dest[dest_index - src_pos + i];

libavcodec/x86/h264_idct_10bit.asm+84−94

@@ -133,7 +133,7 @@ ADD4x4IDCT avx · 132 unmodified lines
133	%macro ADD16_OP 3	133	%macro ADD16_OP 3
134	cmp byte [r4+%3], 0	134	cmp byte [r4+%3], 0
135	jz .skipblock%2	135	jz .skipblock%2
136	mov r5d, dword [r1+%2*4]	136	mov r5d, [r1+%2*4]
137	call add4x4_idct_%1	137	call add4x4_idct_%1
138	.skipblock%2:	138	.skipblock%2:
139	%if %2<15	139	%if %2<15
@@ -159,7 +159,7 @@ cglobal h264_idct_add16_10_%1, 5,6 · 19 unmodified lines
159	ADD16_OP %1, 13, 7+3*8	159	ADD16_OP %1, 13, 7+3*8
160	ADD16_OP %1, 14, 6+4*8	160	ADD16_OP %1, 14, 6+4*8
161	ADD16_OP %1, 15, 7+4*8	161	ADD16_OP %1, 15, 7+4*8
162	RET	162	REP_RET
163	%endmacro	163	%endmacro
164		164
165	INIT_XMM	165	INIT_XMM
@@ -201,7 +201,7 @@ IDCT_ADD16_10 avx · 35 unmodified lines
201		201
202	INIT_MMX	202	INIT_MMX
203	cglobal h264_idct_dc_add_10_mmx2,3,3	203	cglobal h264_idct_dc_add_10_mmx2,3,3
204	movd m0, dword [r1]	204	movd m0, [r1]
205	paddd m0, [pd_32]	205	paddd m0, [pd_32]
206	psrad m0, 6	206	psrad m0, 6
207	lea r1, [r2*3]	207	lea r1, [r2*3]
@@ -215,7 +215,7 @@ cglobal h264_idct_dc_add_10_mmx2,3,3 · 7 unmodified lines
215	;-----------------------------------------------------------------------------	215	;-----------------------------------------------------------------------------
216	%macro IDCT8_DC_ADD 1	216	%macro IDCT8_DC_ADD 1
217	cglobal h264_idct8_dc_add_10_%1,3,3,7	217	cglobal h264_idct8_dc_add_10_%1,3,3,7
218	mov r1d, dword [r1]	218	mov r1d, [r1]
219	add r1, 32	219	add r1, 32
220	sar r1, 6	220	sar r1, 6
221	movd m0, r1d	221	movd m0, r1d
@@ -240,26 +240,27 @@ IDCT8_DC_ADD avx · 18 unmodified lines
240	;-----------------------------------------------------------------------------	240	;-----------------------------------------------------------------------------
241	%macro AC 2	241	%macro AC 2
242	.ac%2	242	.ac%2
243	mov r5d, dword [r1+(%2+0)*4]	243	mov r5d, [r1+(%2+0)*4]
244	call add4x4_idct_%1	244	call add4x4_idct_%1
245	mov r5d, dword [r1+(%2+1)*4]	245	mov r5d, [r1+(%2+1)*4]
246	add r2, 64	246	add r2, 64
247	call add4x4_idct_%1	247	call add4x4_idct_%1
248	add r2, 64	248	add r2, 64
249	jmp .skipadd%2	249	jmp .skipadd%2
250	%endmacro	250	%endmacro
251		251
		252	%assign last_block 16
252	%macro ADD16_OP_INTRA 3	253	%macro ADD16_OP_INTRA 3
253	cmp word [r4+%3], 0	254	cmp word [r4+%3], 0
254	jnz .ac%2	255	jnz .ac%2
255	mov r6d, dword [r2+ 0]	256	mov r5d, [r2+ 0]
256	or r6d, dword [r2+64]	257	or r5d, [r2+64]
257	jz .skipblock%2	258	jz .skipblock%2
258	mov r5d, dword [r1+(%2+0)*4]	259	mov r5d, [r1+(%2+0)*4]
259	call idct_dc_add_%1	260	call idct_dc_add_%1
260	.skipblock%2:	261	.skipblock%2:
261	%if %2<15	262	%if %2<last_block-2
262	add r2, 128	263	add r2, 128
263	%endif	264	%endif
264	.skipadd%2:	265	.skipadd%2:
265	%endmacro	266	%endmacro
@@ -287,12 +288,15 @@ cglobal h264_idct_add16intra_10_%1,5,7,8 · 21 unmodified lines
287	ADD16_OP_INTRA %1, 10, 4+4*8	288	ADD16_OP_INTRA %1, 10, 4+4*8
288	ADD16_OP_INTRA %1, 12, 6+3*8	289	ADD16_OP_INTRA %1, 12, 6+3*8
289	ADD16_OP_INTRA %1, 14, 6+4*8	290	ADD16_OP_INTRA %1, 14, 6+4*8
290	RET	291	REP_RET
291	%assign i 14	292	AC %1, 8
292	%rep 8	293	AC %1, 10
293	AC %1, i	294	AC %1, 12
294	%assign i i-2	295	AC %1, 14
295	%endrep	296	AC %1, 0
		297	AC %1, 2
		298	AC %1, 4
		299	AC %1, 6
296	%endmacro	300	%endmacro
297		301
298	INIT_XMM	302	INIT_XMM
@@ -302,47 +306,33 @@ INIT_AVX · 3 unmodified lines
302	IDCT_ADD16INTRA_10 avx	306	IDCT_ADD16INTRA_10 avx
303	%endif	307	%endif
304		308
		309	%assign last_block 24
305	;-----------------------------------------------------------------------------	310	;-----------------------------------------------------------------------------
306	; h264_idct_add8(pixel *dst, const int block_offset, dctcoef block, int stride, const uint8_t nnzc[68])	311	; h264_idct_add8(pixel *dst, const int block_offset, dctcoef block, int stride, const uint8_t nnzc[68])
307	;-----------------------------------------------------------------------------	312	;-----------------------------------------------------------------------------
308	%macro IDCT_ADD8 1	313	%macro IDCT_ADD8 1
309	cglobal h264_idct_add8_10_%1,5,7	314	cglobal h264_idct_add8_10_%1,5,7
310	mov r5, 16
311	add r2, 1024
312	%ifdef PIC
313	lea r11, [scan8_mem]
314	%endif
315	%ifdef ARCH_X86_64
316	mov r10, r0
317	%endif
318	.nextblock:
319	movzx r6, byte [scan8+r5]
320	movzx r6, byte [r4+r6]
321	or r6d, dword [r2]
322	test r6, r6
323	jz .skipblock
324	%ifdef ARCH_X86_64	315	%ifdef ARCH_X86_64
325	mov r0d, dword [r1+r5*4]	316	mov r10, r0
326	add r0, [r10]
327	%else
328	mov r0, r0m
329	mov r0, [r0]
330	add r0, dword [r1+r5*4]
331	%endif	317	%endif
332	IDCT4_ADD_10 r0, r2, r3	318	add r2, 1024
333	.skipblock:	319	mov r0, [r0]
334	inc r5	320	ADD16_OP_INTRA %1, 16, 1+1*8
335	add r2, 64	321	ADD16_OP_INTRA %1, 18, 1+2*8
336	test r5, 3
337	jnz .nextblock
338	%ifdef ARCH_X86_64	322	%ifdef ARCH_X86_64
339	add r10, gprsize	323	mov r0, [r10+gprsize]
340	%else	324	%else
341	add r0mp, gprsize	325	mov r0, r0m
		326	mov r0, [r0+gprsize]
342	%endif	327	%endif
343	test r5, 4	328	ADD16_OP_INTRA %1, 20, 1+4*8
344	jnz .nextblock	329	ADD16_OP_INTRA %1, 22, 1+5*8
345	REP_RET	330	REP_RET
		331	AC %1, 16
		332	AC %1, 18
		333	AC %1, 20
		334	AC %1, 22
		335
346	%endmacro ; IDCT_ADD8	336	%endmacro ; IDCT_ADD8
347		337
348	INIT_XMM	338	INIT_XMM
@@ -356,51 +346,51 @@ IDCT_ADD8 avx · 7 unmodified lines
356	; void h264_idct8_add(pixel dst, dctcoef block, int stride)	346	; void h264_idct8_add(pixel dst, dctcoef block, int stride)
357	;-----------------------------------------------------------------------------	347	;-----------------------------------------------------------------------------
358	%macro IDCT8_1D 2	348	%macro IDCT8_1D 2
359	SWAP 0, 1	349	SWAP 0, 1
360	psrad m4, m5, 1	350	psrad m4, m5, 1
361	psrad m1, m0, 1	351	psrad m1, m0, 1
362	paddd m4, m5	352	paddd m4, m5
363	paddd m1, m0	353	paddd m1, m0
364	paddd m4, m7	354	paddd m4, m7
365	paddd m1, m5	355	paddd m1, m5
366	psubd m4, m0	356	psubd m4, m0
367	paddd m1, m3	357	paddd m1, m3
368		358
369	psubd m0, m3	359	psubd m0, m3
370	psubd m5, m3	360	psubd m5, m3
371	paddd m0, m7	361	paddd m0, m7
372	psubd m5, m7	362	psubd m5, m7
373	psrad m3, 1	363	psrad m3, 1
374	psrad m7, 1	364	psrad m7, 1
375	psubd m0, m3	365	psubd m0, m3
376	psubd m5, m7	366	psubd m5, m7
377		367
378	SWAP 1, 7	368	SWAP 1, 7
379	psrad m1, m7, 2	369	psrad m1, m7, 2
380	psrad m3, m4, 2	370	psrad m3, m4, 2
381	paddd m3, m0	371	paddd m3, m0
382	psrad m0, 2	372	psrad m0, 2
383	paddd m1, m5	373	paddd m1, m5
384	psrad m5, 2	374	psrad m5, 2
385	psubd m0, m4	375	psubd m0, m4
386	psubd m7, m5	376	psubd m7, m5
387		377
388	SWAP 5, 6	378	SWAP 5, 6
389	psrad m4, m2, 1	379	psrad m4, m2, 1
390	psrad m6, m5, 1	380	psrad m6, m5, 1
391	psubd m4, m5	381	psubd m4, m5
392	paddd m6, m2	382	paddd m6, m2
393		383
394	mova m2, %1	384	mova m2, %1
395	mova m5, %2	385	mova m5, %2
396	SUMSUB_BA d, 5, 2	386	SUMSUB_BA d, 5, 2
397	SUMSUB_BA d, 6, 5	387	SUMSUB_BA d, 6, 5
398	SUMSUB_BA d, 4, 2	388	SUMSUB_BA d, 4, 2
399	SUMSUB_BA d, 7, 6	389	SUMSUB_BA d, 7, 6
400	SUMSUB_BA d, 0, 4	390	SUMSUB_BA d, 0, 4
401	SUMSUB_BA d, 3, 2	391	SUMSUB_BA d, 3, 2
402	SUMSUB_BA d, 1, 5	392	SUMSUB_BA d, 1, 5
403	SWAP 7, 6, 4, 5, 2, 3, 1, 0 ; 70315246 -> 01234567	393	SWAP 7, 6, 4, 5, 2, 3, 1, 0 ; 70315246 -> 01234567
404	%endmacro	394	%endmacro
405		395
406	%macro IDCT8_1D_FULL 1	396	%macro IDCT8_1D_FULL 1
@@ -536,7 +526,7 @@ IDCT8_ADD avx · 129 unmodified lines
536	%macro IDCT8_ADD4_OP 3	526	%macro IDCT8_ADD4_OP 3
537	cmp byte [r4+%3], 0	527	cmp byte [r4+%3], 0
538	jz .skipblock%2	528	jz .skipblock%2
539	mov r0d, dword [r6+%2*4]	529	mov r0d, [r6+%2*4]
540	add r0, r5	530	add r0, r5
541	call h264_idct8_add1_10_%1	531	call h264_idct8_add1_10_%1
542	.skipblock%2:	532	.skipblock%2:

libavcodec/x86/h264_intrapred.asm+0−6

 ;-----------------------------------------------------------------------------
 ; void pred8x8_top_dc_mmxext(uint8_t *src, int stride)
 ;-----------------------------------------------------------------------------
-%ifdef CONFIG_GPL
 cglobal pred8x8_top_dc_mmxext, 2,5
     sub         r0, r1
     movq       mm0, [r0]
     movq [r4+r1*1], m1
     movq [r4+r1*2], m1
     RET
-%endif
 ;-----------------------------------------------------------------------------
 ; void pred8x8_dc_rv40(uint8_t *src, int stride)
 ;-----------------------------------------------------------------------------
 ; void pred8x8l_top_dc(uint8_t *src, int has_topleft, int has_topright, int stride)
 ;-----------------------------------------------------------------------------
-%ifdef CONFIG_GPL
 %macro PRED8x8L_TOP_DC 1
 cglobal pred8x8l_top_dc_%1, 4,4
     sub          r0, r3
 INIT_MMX
 %define PALIGNR PALIGNR_SSSE3
 PRED8x8L_HORIZONTAL_DOWN ssse3
-%endif
 ;-----------------------------------------------------------------------------
 ; void pred4x4_dc_mmxext(uint8_t *src, const uint8_t *topright, int stride)
 ;-----------------------------------------------------------------------------
 ; void pred4x4_down_left_mmxext(uint8_t *src, const uint8_t *topright, int stride)
 ;-----------------------------------------------------------------------------
-%ifdef CONFIG_GPL
 INIT_MMX
 cglobal pred4x4_down_left_mmxext, 3,3
     sub       r0, r2
     psrlq     m0, 8
     movh      [r0+r2*1], m0
     RET
-%endif

libavcodec/x86/h264_intrapred_init.c+0−8

         h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_mmxext;
         h->pred16x16[DC_PRED8x8  ] = ff_pred16x16_dc_mmxext;
         h->pred8x8  [HOR_PRED8x8 ] = ff_pred8x8_horizontal_mmxext;
-#if CONFIG_GPL
         h->pred8x8l [TOP_DC_PRED ] = ff_pred8x8l_top_dc_mmxext;
         h->pred8x8l [DC_PRED     ] = ff_pred8x8l_dc_mmxext;
         h->pred8x8l [HOR_PRED    ] = ff_pred8x8l_horizontal_mmxext;
         h->pred4x4  [DIAG_DOWN_RIGHT_PRED] = ff_pred4x4_down_right_mmxext;
         h->pred4x4  [VERT_RIGHT_PRED     ] = ff_pred4x4_vertical_right_mmxext;
         h->pred4x4  [HOR_DOWN_PRED       ] = ff_pred4x4_horizontal_down_mmxext;
-#endif
         h->pred4x4  [DC_PRED     ] = ff_pred4x4_dc_mmxext;
-#if CONFIG_GPL
         if (codec_id == CODEC_ID_VP8 || codec_id == CODEC_ID_H264)
             h->pred4x4  [DIAG_DOWN_LEFT_PRED ] = ff_pred4x4_down_left_mmxext;
         if (codec_id == CODEC_ID_SVQ3 || codec_id == CODEC_ID_H264)
             h->pred8x8  [TOP_DC_PRED8x8      ] = ff_pred8x8_top_dc_mmxext;
             h->pred8x8  [DC_PRED8x8          ] = ff_pred8x8_dc_mmxext;
         }
-#endif
         if (codec_id == CODEC_ID_VP8) {
             h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_tm_vp8_mmxext;
             h->pred8x8  [DC_PRED8x8   ] = ff_pred8x8_dc_rv40_mmxext;
     if (mm_flags & AV_CPU_FLAG_SSE2) {
         h->pred16x16[DC_PRED8x8  ] = ff_pred16x16_dc_sse2;
-#if CONFIG_GPL
         h->pred8x8l [DIAG_DOWN_LEFT_PRED ] = ff_pred8x8l_down_left_sse2;
         h->pred8x8l [DIAG_DOWN_RIGHT_PRED] = ff_pred8x8l_down_right_sse2;
         h->pred8x8l [VERT_RIGHT_PRED     ] = ff_pred8x8l_vertical_right_sse2;
         h->pred8x8l [VERT_LEFT_PRED      ] = ff_pred8x8l_vertical_left_sse2;
         h->pred8x8l [HOR_DOWN_PRED       ] = ff_pred8x8l_horizontal_down_sse2;
-#endif
         if (codec_id == CODEC_ID_VP8) {
             h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_tm_vp8_sse2;
             h->pred8x8  [PLANE_PRED8x8] = ff_pred8x8_tm_vp8_sse2;
         h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_ssse3;
         h->pred16x16[DC_PRED8x8  ] = ff_pred16x16_dc_ssse3;
         h->pred8x8  [HOR_PRED8x8 ] = ff_pred8x8_horizontal_ssse3;
-#if CONFIG_GPL
         h->pred8x8l [TOP_DC_PRED ] = ff_pred8x8l_top_dc_ssse3;
         h->pred8x8l [DC_PRED     ] = ff_pred8x8l_dc_ssse3;
         h->pred8x8l [HOR_PRED    ] = ff_pred8x8l_horizontal_ssse3;
         h->pred8x8l [VERT_LEFT_PRED      ] = ff_pred8x8l_vertical_left_ssse3;
         h->pred8x8l [HOR_UP_PRED         ] = ff_pred8x8l_horizontal_up_ssse3;
         h->pred8x8l [HOR_DOWN_PRED       ] = ff_pred8x8l_horizontal_down_ssse3;
-#endif
         if (codec_id == CODEC_ID_VP8) {
             h->pred8x8  [PLANE_PRED8x8] = ff_pred8x8_tm_vp8_ssse3;
             h->pred4x4  [TM_VP8_PRED  ] = ff_pred4x4_tm_vp8_ssse3;

libavdevice/bktr.c+13−11

     int video_fd;
     int tuner_fd;
     int width, height;
-    int frame_rate;
-    int frame_rate_base;
     uint64_t per_frame;
     int standard;
     char *video_size; /**< String describing video size, set by a private option. */
+    char *framerate;  /**< Set by a private option. */
 } VideoData;
     VideoData *s = s1->priv_data;
     AVStream *st;
     int width, height;
-    int frame_rate;
+    AVRational fps;
-    int frame_rate_base;
     int ret = 0;
     if (ap->time_base.den <= 0) {
         av_log(s1, AV_LOG_ERROR, "Couldn't parse video size.\n");
         goto out;
     }
+    if ((ret = av_parse_video_rate(&fps, s->framerate)) < 0) {
+        av_log(s1, AV_LOG_ERROR, "Couldn't parse framerate.\n");
+        goto out;
+    }
 #if FF_API_FORMAT_PARAMETERS
     if (ap->width > 0)
         width = ap->width;
     if (ap->height > 0)
         height = ap->height;
+    if (ap->time_base.num)
+        fps = (AVRational){ap->time_base.den, ap->time_base.num};
 #endif
-    frame_rate = ap->time_base.den;
-    frame_rate_base = ap->time_base.num;
     st = av_new_stream(s1, 0);
     if (!st) {
     s->width = width;
     s->height = height;
-    s->frame_rate = frame_rate;
+    s->per_frame = ((uint64_t)1000000 * fps.den) / fps.num;
-    s->frame_rate_base = frame_rate_base;
-    s->per_frame = ((uint64_t)1000000 * s->frame_rate_base) / s->frame_rate;
     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
     st->codec->pix_fmt = PIX_FMT_YUV420P;
     st->codec->codec_id = CODEC_ID_RAWVIDEO;
     st->codec->width = width;
     st->codec->height = height;
-    st->codec->time_base.den = frame_rate;
+    st->codec->time_base.den = fps.num;
-    st->codec->time_base.num = frame_rate_base;
+    st->codec->time_base.num = fps.den;
 #if FF_API_FORMAT_PARAMETERS
     if (ap->standard) {
 out:
     av_freep(&s->video_size);
+    av_freep(&s->framerate);
     return ret;
 }
     { "PALM",     "", 0, FF_OPT_TYPE_CONST, {.dbl = PALM},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
     { "NTSCJ",    "", 0, FF_OPT_TYPE_CONST, {.dbl = NTSCJ}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
     { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), FF_OPT_TYPE_STRING, {.str = "vga"}, 0, 0, DEC },
+    { "framerate", "", OFFSET(framerate), FF_OPT_TYPE_STRING, {.str = "ntsc"}, 0, 0, DEC },
     { NULL },
 };

libavdevice/dv1394.c+2−9

 #include "libavutil/log.h"
 #include "libavutil/opt.h"
 #include "avdevice.h"
-#undef DV1394_DEBUG
 #include "libavformat/dv.h"
 #include "dv1394.h"
             av_log(context, AV_LOG_ERROR, "Failed to get status: %s\n", strerror(errno));
             return AVERROR(EIO);
         }
-#ifdef DV1394_DEBUG
+        av_dlog(context, "DV1394: status\n"
-        av_log(context, AV_LOG_DEBUG, "DV1394: status\n"
                 "\tactive_frame\t%d\n"
                 "\tfirst_clear_frame\t%d\n"
                 "\tn_clear_frames\t%d\n"
                 "\tdropped_frames\t%d\n",
                 s.active_frame, s.first_clear_frame,
                 s.n_clear_frames, s.dropped_frames);
-#endif
         dv->avail = s.n_clear_frames;
         dv->index = s.first_clear_frame;
         }
     }
-#ifdef DV1394_DEBUG
+    av_dlog(context, "index %d, avail %d, done %d\n", dv->index, dv->avail,
-    av_log(context, AV_LOG_DEBUG, "index %d, avail %d, done %d\n", dv->index, dv->avail,
             dv->done);
-#endif
     size = dv_produce_packet(dv->dv_demux, pkt,
                              dv->ring + (dv->index * DV1394_PAL_FRAME_SIZE),

libavdevice/fbdev.c+36−12

 #include <time.h>
 #include <linux/fb.h>
+#include "libavutil/log.h"
 #include "libavutil/mem.h"
+#include "libavutil/opt.h"
+#include "libavutil/parseutils.h"
 #include "libavutil/pixdesc.h"
 #include "avdevice.h"
 }
 typedef struct {
+    AVClass *class;          ///< class for private options
     int frame_size;          ///< size in bytes of a grabbed frame
-    AVRational time_base;    ///< time base
+    AVRational fps;          ///< framerate
+    char *framerate;         ///< framerate string set by a private option
     int64_t time_frame;      ///< time for the next frame to output (in 1/1000000 units)
     int fd;                  ///< framebuffer device file descriptor
     enum PixelFormat pix_fmt;
     int ret, flags = O_RDONLY;
+    ret = av_parse_video_rate(&fbdev->fps, fbdev->framerate);
+    av_freep(&fbdev->framerate);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Couldn't parse framerate.\n");
+        return ret;
+    }
+#if FF_API_FORMAT_PARAMETERS
+    if (ap->time_base.num)
+        fbdev->fps = (AVRational){ap->time_base.den, ap->time_base.num};
+#endif
     if (!(st = av_new_stream(avctx, 0)))
         return AVERROR(ENOMEM);
     av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in microseconds */
-    if (ap->time_base.den <= 0) {
-        av_log(avctx, AV_LOG_ERROR, "Invalid time base %d/%d\n",
-               ap->time_base.num, ap->time_base.den);
-        return AVERROR(EINVAL);
-    }
     /* NONBLOCK is ignored by the fbdev driver, only set for consistency */
     if (avctx->flags & AVFMT_FLAG_NONBLOCK)
         flags |= O_NONBLOCK;
     fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;
     fbdev->frame_linesize  = fbdev->width * fbdev->bytes_per_pixel;
     fbdev->frame_size      = fbdev->frame_linesize * fbdev->heigth;
-    fbdev->time_base       = ap->time_base;
     fbdev->time_frame      = AV_NOPTS_VALUE;
     fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);
     if (fbdev->data == MAP_FAILED) {
     st->codec->pix_fmt    = pix_fmt;
     st->codec->time_base  = ap->time_base;
     st->codec->bit_rate   =
-        fbdev->width * fbdev->heigth * fbdev->bytes_per_pixel / av_q2d(ap->time_base) * 8;
+        fbdev->width * fbdev->heigth * fbdev->bytes_per_pixel * av_q2d(fbdev->fps) * 8;
     av_log(avctx, AV_LOG_INFO,
-           "w:%d h:%d bpp:%d pixfmt:%s tb:%d/%d bit_rate:%d\n",
+           "w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n",
            fbdev->width, fbdev->heigth, fbdev->varinfo.bits_per_pixel,
            av_pix_fmt_descriptors[pix_fmt].name,
-           ap->time_base.num, ap->time_base.den,
+           fbdev->fps.num, fbdev->fps.den,
            st->codec->bit_rate);
     return 0;
                 "time_frame:%"PRId64" curtime:%"PRId64" delay:%"PRId64"\n",
                 fbdev->time_frame, curtime, delay);
         if (delay <= 0) {
-            fbdev->time_frame += INT64_C(1000000) * av_q2d(fbdev->time_base);
+            fbdev->time_frame += INT64_C(1000000) / av_q2d(fbdev->fps);
             break;
         }
         if (avctx->flags & AVFMT_FLAG_NONBLOCK)
     return 0;
 }
+#define OFFSET(x) offsetof(FBDevContext, x)
+#define DEC AV_OPT_FLAG_DECODING_PARAM
+static const AVOption options[] = {
+    { "framerate","", OFFSET(framerate), FF_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
+    { NULL },
+};
+static const AVClass fbdev_class = {
+    .class_name = "fbdev indev",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
 AVInputFormat ff_fbdev_demuxer = {
     .name           = "fbdev",
     .long_name      = NULL_IF_CONFIG_SMALL("Linux framebuffer"),
     .read_packet    = fbdev_read_packet,
     .read_close     = fbdev_read_close,
     .flags          = AVFMT_NOFILE,
+    .priv_class     = &fbdev_class,
 };

libavdevice/libdc1394.c+257−189

@@ -2,7 +2,6 @@ · 1 unmodified line
2	* IIDC1394 grab interface (uses libdc1394 and libraw1394)	2	* IIDC1394 grab interface (uses libdc1394 and libraw1394)
3	* Copyright (c) 2004 Roman Shaposhnik	3	* Copyright (c) 2004 Roman Shaposhnik
4	* Copyright (c) 2008 Alessandro Sappia	4	* Copyright (c) 2008 Alessandro Sappia
5	* Copyright (c) 2011 Martin Lambers
6	*	5	*
7	* This file is part of FFmpeg.	6	* This file is part of FFmpeg.
8	*	7	*
@@ -22,47 +21,63 @@ · 13 unmodified lines
22	*/	21	*/
23		22
24	#include "config.h"	23	#include "config.h"
		24	#include "libavformat/avformat.h"
25	#include "libavutil/log.h"	25	#include "libavutil/log.h"
26	#include "libavutil/opt.h"	26	#include "libavutil/opt.h"
27	#include "avdevice.h"
28
29	#include <stdlib.h>
30	#include <string.h>
31	#include "libavutil/parseutils.h"	27	#include "libavutil/parseutils.h"
32	#include "libavutil/pixdesc.h"	28	#include "libavutil/pixdesc.h"
33		29
		30	#if HAVE_LIBDC1394_2
34	#include <dc1394/dc1394.h>	31	#include <dc1394/dc1394.h>
		32	#elif HAVE_LIBDC1394_1
		33	#include <libraw1394/raw1394.h>
		34	#include <libdc1394/dc1394_control.h>
		35
		36	#define DC1394_VIDEO_MODE_320x240_YUV422 MODE_320x240_YUV422
		37	#define DC1394_VIDEO_MODE_640x480_YUV411 MODE_640x480_YUV411
		38	#define DC1394_VIDEO_MODE_640x480_YUV422 MODE_640x480_YUV422
		39	#define DC1394_FRAMERATE_1_875 FRAMERATE_1_875
		40	#define DC1394_FRAMERATE_3_75 FRAMERATE_3_75
		41	#define DC1394_FRAMERATE_7_5 FRAMERATE_7_5
		42	#define DC1394_FRAMERATE_15 FRAMERATE_15
		43	#define DC1394_FRAMERATE_30 FRAMERATE_30
		44	#define DC1394_FRAMERATE_60 FRAMERATE_60
		45	#define DC1394_FRAMERATE_120 FRAMERATE_120
		46	#define DC1394_FRAMERATE_240 FRAMERATE_240
		47	#endif
35		48
36	#undef free	49	#undef free
37		50
38	typedef struct dc1394_data {	51	typedef struct dc1394_data {
39	AVClass *class;	52	AVClass *class;
		53	#if HAVE_LIBDC1394_1
		54	raw1394handle_t handle;
		55	dc1394_cameracapture camera;
		56	int channel;
		57	#elif HAVE_LIBDC1394_2
40	dc1394_t *d;	58	dc1394_t *d;
41	dc1394camera_t *camera;	59	dc1394camera_t *camera;
42	dc1394video_frame_t *frame;	60	dc1394video_frame_t *frame;
		61	#endif
43	int current_frame;	62	int current_frame;
44	int fps;	63	int frame_rate; /*< frames per 1000 seconds (fps 1000) */
45	char video_size; /< String describing video size, set by a private option. /	64	char video_size; /< String describing video size, set by a private option. /
46	char pixel_format; /< Set by a private option. /	65	char pixel_format; /< Set by a private option. /
		66	char framerate; /< Set by a private option. /
47		67
48	AVPacket packet;	68	AVPacket packet;
49	} dc1394_data;	69	} dc1394_data;
50		70
51	/* The list of color codings that we support.	71	struct dc1394_frame_format {
52	* We assume big endian for the dc1394 16bit modes: libdc1394 never sets the	72	int width;
53	* flag little_endian in dc1394video_frame_t. */	73	int height;
54	struct dc1394_color_coding {	74	enum PixelFormat pix_fmt;
55	int pix_fmt;	75	int frame_size_id;
56	int score;	76	} dc1394_frame_formats[] = {
57	uint32_t coding;	77	{ 320, 240, PIX_FMT_UYVY422, DC1394_VIDEO_MODE_320x240_YUV422 },
58	} dc1394_color_codings[] = {	78	{ 640, 480, PIX_FMT_UYYVYY411, DC1394_VIDEO_MODE_640x480_YUV411 },
59	{ PIX_FMT_GRAY16BE, 1000, DC1394_COLOR_CODING_MONO16 },	79	{ 640, 480, PIX_FMT_UYVY422, DC1394_VIDEO_MODE_640x480_YUV422 },
60	{ PIX_FMT_RGB48BE, 1100, DC1394_COLOR_CODING_RGB16 },	80	{ 0, 0, 0, 0 } /* gotta be the last one */
61	{ PIX_FMT_GRAY8, 1200, DC1394_COLOR_CODING_MONO8 },
62	{ PIX_FMT_RGB24, 1300, DC1394_COLOR_CODING_RGB8 },
63	{ PIX_FMT_UYYVYY411, 1400, DC1394_COLOR_CODING_YUV411 },
64	{ PIX_FMT_UYVY422, 1500, DC1394_COLOR_CODING_YUV422 },
65	{ PIX_FMT_NONE, 0, 0 } /* gotta be the last one */
66	};	81	};
67		82
68	struct dc1394_frame_rate {	83	struct dc1394_frame_rate {
@@ -83,8 +98,12 @@ struct dc1394_frame_rate { · 14 unmodified lines
83	#define OFFSET(x) offsetof(dc1394_data, x)	98	#define OFFSET(x) offsetof(dc1394_data, x)
84	#define DEC AV_OPT_FLAG_DECODING_PARAM	99	#define DEC AV_OPT_FLAG_DECODING_PARAM
85	static const AVOption options[] = {	100	static const AVOption options[] = {
		101	#if HAVE_LIBDC1394_1
		102	{ "channel", "", offsetof(dc1394_data, channel), FF_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
		103	#endif
86	{ "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), FF_OPT_TYPE_STRING, {.str = "qvga"}, 0, 0, DEC },	104	{ "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), FF_OPT_TYPE_STRING, {.str = "qvga"}, 0, 0, DEC },
87	{ "pixel_format", "", OFFSET(pixel_format), FF_OPT_TYPE_STRING, {.str = "uyvy422"}, 0, 0, DEC },	105	{ "pixel_format", "", OFFSET(pixel_format), FF_OPT_TYPE_STRING, {.str = "uyvy422"}, 0, 0, DEC },
		106	{ "framerate", "", OFFSET(framerate), FF_OPT_TYPE_STRING, {.str = "ntsc"}, 0, 0, DEC },
88	{ NULL },	107	{ NULL },
89	};	108	};
90		109
@@ -95,183 +114,220 @@ static const AVClass libdc1394_class = { · 4 unmodified lines
95	.version = LIBAVUTIL_VERSION_INT,	114	.version = LIBAVUTIL_VERSION_INT,
96	};	115	};
97		116
98	static int dc1394_read_header(AVFormatContext c, AVFormatParameters ap)	117
		118	static inline int dc1394_read_common(AVFormatContext c, AVFormatParameters ap,
		119	struct dc1394_frame_format select_fmt, struct dc1394_frame_rate select_fps)
99	{	120	{
100	dc1394_data* dc1394 = c->priv_data;	121	dc1394_data* dc1394 = c->priv_data;
101	AVStream *vst;	122	AVStream* vst;
102	const struct dc1394_color_coding *cc;	123	struct dc1394_frame_format *fmt;
103	const struct dc1394_frame_rate *fr;	124	struct dc1394_frame_rate *fps;
104	dc1394camera_list_t *list;	125	enum PixelFormat pix_fmt;
105	dc1394video_modes_t video_modes;	126	int width, height;
106	dc1394video_mode_t video_mode;	127	AVRational framerate;
107	dc1394framerates_t frame_rates;	128	int ret = 0;
108	dc1394framerate_t frame_rate;	129
109	uint32_t dc1394_width, dc1394_height, dc1394_color_coding;	130	if ((pix_fmt = av_get_pix_fmt(dc1394->pixel_format)) == PIX_FMT_NONE) {
110	int rate, best_rate;	131	av_log(c, AV_LOG_ERROR, "No such pixel format: %s.\n", dc1394->pixel_format);
111	int score, max_score;	132	ret = AVERROR(EINVAL);
112	int final_width, final_height, final_pix_fmt, final_frame_rate;
113	int res, i, j;
114	int ret=-1;
115
116	/* Now let us prep the hardware. */
117	dc1394->d = dc1394_new();
118	dc1394_camera_enumerate (dc1394->d, &list);
119	if ( !list \|\| list->num == 0) {
120	av_log(c, AV_LOG_ERROR, "Unable to look for an IIDC camera\n\n");
121	goto out;	133	goto out;
122	}	134	}
123		135
124	/* FIXME: To select a specific camera I need to search in list its guid */	136	if ((ret = av_parse_video_size(&width, &height, dc1394->video_size)) < 0) {
125	dc1394->camera = dc1394_camera_new (dc1394->d, list->ids[0].guid);	137	av_log(c, AV_LOG_ERROR, "Couldn't parse video size.\n");
126	if (list->num > 1) {	138	goto out;
127	av_log(c, AV_LOG_INFO, "Working with the first camera found\n");
128	}
129
130	/* Freeing list of cameras */
131	dc1394_camera_free_list (list);
132
133	/* Get the list of video modes supported by the camera. */
134	res = dc1394_video_get_supported_modes (dc1394->camera, &video_modes);
135	if (res != DC1394_SUCCESS) {
136	av_log(c, AV_LOG_ERROR, "Could not get video formats.\n");
137	goto out_camera;
138	}
139
140	if (dc1394->pixel_format) {
141	if ((ap->pix_fmt = av_get_pix_fmt(dc1394->pixel_format)) == PIX_FMT_NONE) {
142	av_log(c, AV_LOG_ERROR, "No such pixel format: %s.\n", dc1394->pixel_format);
143	ret = AVERROR(EINVAL);
144	goto out;
145	}
146	}
147
148	if (dc1394->video_size) {
149	if ((ret = av_parse_video_size(&ap->width, &ap->height, dc1394->video_size)) < 0) {
150	av_log(c, AV_LOG_ERROR, "Couldn't parse video size.\n");
151	goto out;
152	}
153	}
154
155	/* Choose the best mode. */
156	rate = (ap->time_base.num ? av_rescale(1000, ap->time_base.den, ap->time_base.num) : -1);
157	max_score = -1;
158	for (i = 0; i < video_modes.num; i++) {
159	if (video_modes.modes[i] == DC1394_VIDEO_MODE_EXIF
160	\|\| (video_modes.modes[i] >= DC1394_VIDEO_MODE_FORMAT7_MIN
161	&& video_modes.modes[i] <= DC1394_VIDEO_MODE_FORMAT7_MAX)) {
162	/* These modes are currently not supported as they would require
163	* much more work. For the remaining modes, the functions
164	* dc1394_get_image_size_from_video_mode and
165	* dc1394_get_color_coding_from_video_mode do not need to query the
166	* camera, and thus cannot fail. */
167	continue;
168	}
169	dc1394_get_color_coding_from_video_mode (NULL, video_modes.modes[i],
170	&dc1394_color_coding);
171	for (cc = dc1394_color_codings; cc->pix_fmt != PIX_FMT_NONE; cc++)
172	if (cc->coding == dc1394_color_coding)
173	break;
174	if (cc->pix_fmt == PIX_FMT_NONE) {
175	/* We currently cannot handle this color coding. */
176	continue;
177	}
178	/* Here we know that the mode is supported. Get its frame size and the list
179	* of frame rates supported by the camera for this mode. This list is sorted
180	* in ascending order according to libdc1394 example programs. */
181	dc1394_get_image_size_from_video_mode (NULL, video_modes.modes[i],
182	&dc1394_width, &dc1394_height);
183	res = dc1394_video_get_supported_framerates (dc1394->camera, video_modes.modes[i],
184	&frame_rates);
185	if (res != DC1394_SUCCESS \|\| frame_rates.num == 0) {
186	av_log(c, AV_LOG_ERROR, "Cannot get frame rates for video mode.\n");
187	goto out_camera;
188	}
189	/* Choose the best frame rate. */
190	best_rate = -1;
191	for (j = 0; j < frame_rates.num; j++) {
192	for (fr = dc1394_frame_rates; fr->frame_rate; fr++) {
193	if (fr->frame_rate_id == frame_rates.framerates[j]) {
194	break;
195	}
196	}
197	if (!fr->frame_rate) {
198	/* This frame rate is not supported. */
199	continue;
200	}
201	best_rate = fr->frame_rate;
202	frame_rate = fr->frame_rate_id;
203	if (ap->time_base.num && rate == fr->frame_rate) {
204	/* This is the requested frame rate. */
205	break;
206	}
207	}
208	if (best_rate == -1) {
209	/* No supported rate found. */
210	continue;
211	}
212	/* Here we know that both the mode and the rate are supported. Compute score. */
213	if (ap->width && ap->height
214	&& (dc1394_width == ap->width && dc1394_height == ap->height)) {
215	score = 110000;
216	} else {
217	score = dc1394_width * 10; // 1600 - 16000
218	}
219	if (ap->pix_fmt == cc->pix_fmt) {
220	score += 90000;
221	} else {
222	score += cc->score; // 1000 - 1500
223	}
224	if (ap->time_base.num && rate == best_rate) {
225	score += 70000;
226	} else {
227	score += best_rate / 1000; // 1 - 240
228	}
229	if (score > max_score) {
230	video_mode = video_modes.modes[i];
231	final_width = dc1394_width;
232	final_height = dc1394_height;
233	final_pix_fmt = cc->pix_fmt;
234	final_frame_rate = best_rate;
235	max_score = score;
236	}
237	}
238	if (max_score == -1) {
239	av_log(c, AV_LOG_ERROR, "No suitable video mode / frame rate available.\n");
240	goto out_camera;
241	}
242	if (ap->width && ap->height && !(ap->width == final_width && ap->height == final_height)) {
243	av_log(c, AV_LOG_WARNING, "Requested frame size is not available, using fallback.\n");
244	}	139	}
245	if (ap->pix_fmt != PIX_FMT_NONE && ap->pix_fmt != final_pix_fmt) {	140	if ((ret = av_parse_video_rate(&framerate, dc1394->framerate)) < 0) {
246	av_log(c, AV_LOG_WARNING, "Requested pixel format is not supported, using fallback.\n");	141	av_log(c, AV_LOG_ERROR, "Couldn't parse framerate.\n");
		142	goto out;
247	}	143	}
248	if (ap->time_base.num && rate != final_frame_rate) {	144	#if FF_API_FORMAT_PARAMETERS
249	av_log(c, AV_LOG_WARNING, "Requested frame rate is not available, using fallback.\n");	145	if (ap->width > 0)
		146	width = ap->width;
		147	if (ap->height > 0)
		148	height = ap->height;
		149	if (ap->pix_fmt)
		150	pix_fmt = ap->pix_fmt;
		151	if (ap->time_base.num)
		152	framerate = (AVRational){ap->time_base.den, ap->time_base.num};
		153	#endif
		154	dc1394->frame_rate = av_rescale(1000, framerate.num, framerate.den);
		155
		156	for (fmt = dc1394_frame_formats; fmt->width; fmt++)
		157	if (fmt->pix_fmt == pix_fmt && fmt->width == width && fmt->height == height)
		158	break;
		159
		160	for (fps = dc1394_frame_rates; fps->frame_rate; fps++)
		161	if (fps->frame_rate == dc1394->frame_rate)
		162	break;
		163
		164	if (!fps->frame_rate \|\| !fmt->width) {
		165	av_log(c, AV_LOG_ERROR, "Can't find matching camera format for %s, %dx%d@%d:1000fps\n", avcodec_get_pix_fmt_name(pix_fmt),
		166	width, height, dc1394->frame_rate);
		167	ret = AVERROR(EINVAL);
		168	goto out;
250	}	169	}
251		170
252	/* create a video stream */	171	/* create a video stream */
253	vst = av_new_stream(c, 0);	172	vst = av_new_stream(c, 0);
254	if (!vst)	173	if (!vst) {
255	goto out_camera;	174	ret = AVERROR(ENOMEM);
		175	goto out;
		176	}
256	av_set_pts_info(vst, 64, 1, 1000);	177	av_set_pts_info(vst, 64, 1, 1000);
257	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;	178	vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
258	vst->codec->codec_id = CODEC_ID_RAWVIDEO;	179	vst->codec->codec_id = CODEC_ID_RAWVIDEO;
259	vst->codec->time_base.den = final_frame_rate;	180	vst->codec->time_base.den = framerate.num;
260	vst->codec->time_base.num = 1000;	181	vst->codec->time_base.num = framerate.den;
261	vst->codec->width = final_width;	182	vst->codec->width = fmt->width;
262	vst->codec->height = final_height;	183	vst->codec->height = fmt->height;
263	vst->codec->pix_fmt = final_pix_fmt;	184	vst->codec->pix_fmt = fmt->pix_fmt;
264		185
265	/* packet init */	186	/* packet init */
266	av_init_packet(&dc1394->packet);	187	av_init_packet(&dc1394->packet);
267	dc1394->packet.size = avpicture_get_size(final_pix_fmt, final_width, final_height);	188	dc1394->packet.size = avpicture_get_size(fmt->pix_fmt, fmt->width, fmt->height);
268	dc1394->packet.stream_index = vst->index;	189	dc1394->packet.stream_index = vst->index;
269	dc1394->packet.flags \|= AV_PKT_FLAG_KEY;	190	dc1394->packet.flags \|= AV_PKT_FLAG_KEY;
270		191
271	dc1394->current_frame = 0;	192	dc1394->current_frame = 0;
272	dc1394->fps = final_frame_rate;
273		193
274	vst->codec->bit_rate = av_rescale(dc1394->packet.size * 8, final_frame_rate, 1000);	194	vst->codec->bit_rate = av_rescale(dc1394->packet.size * 8, fps->frame_rate, 1000);
		195	*select_fps = fps;
		196	*select_fmt = fmt;
		197	out:
		198	av_freep(&dc1394->video_size);
		199	av_freep(&dc1394->pixel_format);
		200	av_freep(&dc1394->framerate);
		201	return ret;
		202	}
		203
		204	#if HAVE_LIBDC1394_1
		205	static int dc1394_v1_read_header(AVFormatContext c, AVFormatParameters ap)
		206	{
		207	dc1394_data* dc1394 = c->priv_data;
		208	AVStream* vst;
		209	nodeid_t* camera_nodes;
		210	int res;
		211	struct dc1394_frame_format *fmt = NULL;
		212	struct dc1394_frame_rate *fps = NULL;
		213
		214	if (dc1394_read_common(c,ap,&fmt,&fps) != 0)
		215	return -1;
		216
		217	#if FF_API_FORMAT_PARAMETERS
		218	if (ap->channel)
		219	dc1394->channel = ap->channel;
		220	#endif
		221
		222	/* Now let us prep the hardware. */
		223	dc1394->handle = dc1394_create_handle(0); /* FIXME: gotta have ap->port */
		224	if (!dc1394->handle) {
		225	av_log(c, AV_LOG_ERROR, "Can't acquire dc1394 handle on port %d\n", 0 /* ap->port */);
		226	goto out;
		227	}
		228	camera_nodes = dc1394_get_camera_nodes(dc1394->handle, &res, 1);
		229	if (!camera_nodes \|\| camera_nodes[dc1394->channel] == DC1394_NO_CAMERA) {
		230	av_log(c, AV_LOG_ERROR, "There's no IIDC camera on the channel %d\n", dc1394->channel);
		231	goto out_handle;
		232	}
		233	res = dc1394_dma_setup_capture(dc1394->handle, camera_nodes[dc1394->channel],
		234	0,
		235	FORMAT_VGA_NONCOMPRESSED,
		236	fmt->frame_size_id,
		237	SPEED_400,
		238	fps->frame_rate_id, 8, 1,
		239	c->filename,
		240	&dc1394->camera);
		241	dc1394_free_camera_nodes(camera_nodes);
		242	if (res != DC1394_SUCCESS) {
		243	av_log(c, AV_LOG_ERROR, "Can't prepare camera for the DMA capture\n");
		244	goto out_handle;
		245	}
		246
		247	res = dc1394_start_iso_transmission(dc1394->handle, dc1394->camera.node);
		248	if (res != DC1394_SUCCESS) {
		249	av_log(c, AV_LOG_ERROR, "Can't start isochronous transmission\n");
		250	goto out_handle_dma;
		251	}
		252
		253	return 0;
		254
		255	out_handle_dma:
		256	dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
		257	dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
		258	out_handle:
		259	dc1394_destroy_handle(dc1394->handle);
		260	out:
		261	return -1;
		262	}
		263
		264	static int dc1394_v1_read_packet(AVFormatContext c, AVPacket pkt)
		265	{
		266	struct dc1394_data *dc1394 = c->priv_data;
		267	int res;
		268
		269	/* discard stale frame */
		270	if (dc1394->current_frame++) {
		271	if (dc1394_dma_done_with_buffer(&dc1394->camera) != DC1394_SUCCESS)
		272	av_log(c, AV_LOG_ERROR, "failed to release %d frame\n", dc1394->current_frame);
		273	}
		274
		275	res = dc1394_dma_single_capture(&dc1394->camera);
		276
		277	if (res == DC1394_SUCCESS) {
		278	dc1394->packet.data = (uint8_t *)(dc1394->camera.capture_buffer);
		279	dc1394->packet.pts = (dc1394->current_frame * 1000000) / dc1394->frame_rate;
		280	res = dc1394->packet.size;
		281	} else {
		282	av_log(c, AV_LOG_ERROR, "DMA capture failed\n");
		283	dc1394->packet.data = NULL;
		284	res = -1;
		285	}
		286
		287	*pkt = dc1394->packet;
		288	return res;
		289	}
		290
		291	static int dc1394_v1_close(AVFormatContext * context)
		292	{
		293	struct dc1394_data *dc1394 = context->priv_data;
		294
		295	dc1394_stop_iso_transmission(dc1394->handle, dc1394->camera.node);
		296	dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
		297	dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
		298	dc1394_destroy_handle(dc1394->handle);
		299
		300	return 0;
		301	}
		302
		303	#elif HAVE_LIBDC1394_2
		304	static int dc1394_v2_read_header(AVFormatContext c, AVFormatParameters ap)
		305	{
		306	dc1394_data* dc1394 = c->priv_data;
		307	dc1394camera_list_t *list;
		308	int res, i;
		309	struct dc1394_frame_format *fmt = NULL;
		310	struct dc1394_frame_rate *fps = NULL;
		311
		312	if (dc1394_read_common(c,ap,&fmt,&fps) != 0)
		313	return -1;
		314
		315	/* Now let us prep the hardware. */
		316	dc1394->d = dc1394_new();
		317	dc1394_camera_enumerate (dc1394->d, &list);
		318	if ( !list \|\| list->num == 0) {
		319	av_log(c, AV_LOG_ERROR, "Unable to look for an IIDC camera\n\n");
		320	goto out;
		321	}
		322
		323	/* FIXME: To select a specific camera I need to search in list its guid */
		324	dc1394->camera = dc1394_camera_new (dc1394->d, list->ids[0].guid);
		325	if (list->num > 1) {
		326	av_log(c, AV_LOG_INFO, "Working with the first camera found\n");
		327	}
		328
		329	/* Freeing list of cameras */
		330	dc1394_camera_free_list (list);
275		331
276	/* Select MAX Speed possible from the cam */	332	/* Select MAX Speed possible from the cam */
277	if (dc1394->camera->bmode_capable>0) {	333	if (dc1394->camera->bmode_capable>0) {
@@ -289,13 +345,13 @@ static int dc1394_read_header(AVFormatContext c, AVFormatParameters ap) · 11 unmodified lines
289	goto out_camera;	345	goto out_camera;
290	}	346	}
291		347
292	if (dc1394_video_set_mode(dc1394->camera, video_mode) != DC1394_SUCCESS) {	348	if (dc1394_video_set_mode(dc1394->camera, fmt->frame_size_id) != DC1394_SUCCESS) {
293	av_log(c, AV_LOG_ERROR, "Couldn't set video format\n");	349	av_log(c, AV_LOG_ERROR, "Couldn't set video format\n");
294	goto out_camera;	350	goto out_camera;
295	}	351	}
296		352
297	if (dc1394_video_set_framerate(dc1394->camera, frame_rate) != DC1394_SUCCESS) {	353	if (dc1394_video_set_framerate(dc1394->camera,fps->frame_rate_id) != DC1394_SUCCESS) {
298	av_log(c, AV_LOG_ERROR, "Could not set framerate %d.\n", final_frame_rate);	354	av_log(c, AV_LOG_ERROR, "Couldn't set framerate %d \n",fps->frame_rate);
299	goto out_camera;	355	goto out_camera;
300	}	356	}
301	if (dc1394_capture_setup(dc1394->camera, 10, DC1394_CAPTURE_FLAGS_DEFAULT)!=DC1394_SUCCESS) {	357	if (dc1394_capture_setup(dc1394->camera, 10, DC1394_CAPTURE_FLAGS_DEFAULT)!=DC1394_SUCCESS) {
@@ -314,13 +370,11 @@ out_camera: · 12 unmodified lines
314	dc1394_video_set_transmission(dc1394->camera, DC1394_OFF);	370	dc1394_video_set_transmission(dc1394->camera, DC1394_OFF);
315	dc1394_camera_free (dc1394->camera);	371	dc1394_camera_free (dc1394->camera);
316	out:	372	out:
317	av_freep(&dc1394->video_size);
318	av_freep(&dc1394->pixel_format);
319	dc1394_free(dc1394->d);	373	dc1394_free(dc1394->d);
320	return ret;	374	return -1;
321	}	375	}
322		376
323	static int dc1394_read_packet(AVFormatContext c, AVPacket pkt)	377	static int dc1394_v2_read_packet(AVFormatContext c, AVPacket pkt)
324	{	378	{
325	struct dc1394_data *dc1394 = c->priv_data;	379	struct dc1394_data *dc1394 = c->priv_data;
326	int res;	380	int res;
@@ -334,7 +388,7 @@ static int dc1394_read_packet(AVFormatContext c, AVPacket pkt) · 7 unmodified lines
334	res = dc1394_capture_dequeue(dc1394->camera, DC1394_CAPTURE_POLICY_WAIT, &dc1394->frame);	388	res = dc1394_capture_dequeue(dc1394->camera, DC1394_CAPTURE_POLICY_WAIT, &dc1394->frame);
335	if (res == DC1394_SUCCESS) {	389	if (res == DC1394_SUCCESS) {
336	dc1394->packet.data = (uint8_t *)(dc1394->frame->image);	390	dc1394->packet.data = (uint8_t *)(dc1394->frame->image);
337	dc1394->packet.pts = (dc1394->current_frame * 1000000) / (dc1394->fps);	391	dc1394->packet.pts = (dc1394->current_frame * 1000000) / (dc1394->frame_rate);
338	res = dc1394->frame->image_bytes;	392	res = dc1394->frame->image_bytes;
339	} else {	393	} else {
340	av_log(c, AV_LOG_ERROR, "DMA capture failed\n");	394	av_log(c, AV_LOG_ERROR, "DMA capture failed\n");
@@ -346,7 +400,7 @@ static int dc1394_read_packet(AVFormatContext c, AVPacket pkt) · 5 unmodified lines
346	return res;	400	return res;
347	}	401	}
348		402
349	static int dc1394_close(AVFormatContext * context)	403	static int dc1394_v2_close(AVFormatContext * context)
350	{	404	{
351	struct dc1394_data *dc1394 = context->priv_data;	405	struct dc1394_data *dc1394 = context->priv_data;
352		406
@@ -360,11 +414,25 @@ static int dc1394_close(AVFormatContext * context) · 7 unmodified lines
360		414
361	AVInputFormat ff_libdc1394_demuxer = {	415	AVInputFormat ff_libdc1394_demuxer = {
362	.name = "libdc1394",	416	.name = "libdc1394",
363	.long_name = NULL_IF_CONFIG_SMALL("dc1394 A/V grab"),	417	.long_name = NULL_IF_CONFIG_SMALL("dc1394 v.2 A/V grab"),
		418	.priv_data_size = sizeof(struct dc1394_data),
		419	.read_header = dc1394_v2_read_header,
		420	.read_packet = dc1394_v2_read_packet,
		421	.read_close = dc1394_v2_close,
		422	.flags = AVFMT_NOFILE,
		423	.priv_class = &libdc1394_class,
		424	};
		425
		426	#endif
		427	#if HAVE_LIBDC1394_1
		428	AVInputFormat ff_libdc1394_demuxer = {
		429	.name = "libdc1394",
		430	.long_name = NULL_IF_CONFIG_SMALL("dc1394 v.1 A/V grab"),
364	.priv_data_size = sizeof(struct dc1394_data),	431	.priv_data_size = sizeof(struct dc1394_data),
365	.read_header = dc1394_read_header,	432	.read_header = dc1394_v1_read_header,
366	.read_packet = dc1394_read_packet,	433	.read_packet = dc1394_v1_read_packet,
367	.read_close = dc1394_close,	434	.read_close = dc1394_v1_close,
368	.flags = AVFMT_NOFILE,	435	.flags = AVFMT_NOFILE,
369	.priv_class = &libdc1394_class,	436	.priv_class = &libdc1394_class,
370	};	437	};
		438	#endif

libavdevice/v4l2.c+20−12

     int channel;
     char *video_size; /**< String describing video size, set by a private option. */
     char *pixel_format; /**< Set by a private option. */
+    char *framerate;    /**< Set by a private option. */
 };
 struct buff_data {
     struct v4l2_streamparm streamparm = {0};
     struct v4l2_fract *tpf = &streamparm.parm.capture.timeperframe;
     int i, ret;
+    AVRational fps;
     streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if (s->framerate && (ret = av_parse_video_rate(&fps, s->framerate)) < 0) {
+        av_log(s1, AV_LOG_ERROR, "Couldn't parse framerate.\n");
+        return ret;
+    }
 #if FF_API_FORMAT_PARAMETERS
     if (ap->channel > 0)
         s->channel = ap->channel;
+    if (ap->time_base.num)
+        fps = (AVRational){ap->time_base.den, ap->time_base.num};
 #endif
     /* set tv video input */
         }
     }
-    if (ap->time_base.num && ap->time_base.den) {
+    if (fps.num && fps.den) {
         av_log(s1, AV_LOG_DEBUG, "Setting time per frame to %d/%d\n",
-               ap->time_base.num, ap->time_base.den);
+               fps.den, fps.num);
-        tpf->numerator = ap->time_base.num;
+        tpf->numerator   = fps.den;
-        tpf->denominator = ap->time_base.den;
+        tpf->denominator = fps.num;
         if (ioctl(s->fd, VIDIOC_S_PARM, &streamparm) != 0) {
             av_log(s1, AV_LOG_ERROR,
                    "ioctl set time per frame(%d/%d) failed\n",
-                   ap->time_base.num, ap->time_base.den);
+                   fps.den, fps.num);
             return AVERROR(EIO);
         }
-        if (ap->time_base.den != tpf->denominator ||
+        if (fps.num != tpf->denominator ||
-            ap->time_base.num != tpf->numerator) {
+            fps.den != tpf->numerator) {
             av_log(s1, AV_LOG_INFO,
                    "The driver changed the time per frame from %d/%d to %d/%d\n",
-                   ap->time_base.num, ap->time_base.den,
+                   fps.den, fps.num,
                    tpf->numerator, tpf->denominator);
         }
     } else {
-        /* if timebase value is not set in ap, read the timebase value from the driver */
+        /* if timebase value is not set, read the timebase value from the driver */
         if (ioctl(s->fd, VIDIOC_G_PARM, &streamparm) != 0) {
             av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n", strerror(errno));
             return AVERROR(errno);
         }
     }
-    ap->time_base.num = tpf->numerator;
-    ap->time_base.den = tpf->denominator;
     return 0;
 }
     desired_format = device_try_init(s1, pix_fmt, &s->width, &s->height, &codec_id);
     if (desired_format == 0) {
         av_log(s1, AV_LOG_ERROR, "Cannot find a proper format for "
-               "codec_id %d, pix_fmt %d.\n", s1->video_codec_id, ap->pix_fmt);
+               "codec_id %d, pix_fmt %d.\n", s1->video_codec_id, pix_fmt);
         close(s->fd);
         res = AVERROR(EIO);
     av_freep(&s->video_size);
     av_freep(&s->pixel_format);
     av_freep(&s->standard);
+    av_freep(&s->framerate);
     return res;
 }
     { "channel",  "", OFFSET(channel),  FF_OPT_TYPE_INT,    {.dbl = 0 }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
     { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), FF_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
     { "pixel_format", "", OFFSET(pixel_format), FF_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
+    { "framerate", "", OFFSET(framerate), FF_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
     { NULL },
 };

libavdevice/vfwcap.c+11−9

 #include <vfw.h>
 #include "avdevice.h"
-//#define DEBUG_VFW
 /* Defines for VFW missing from MinGW.
  * Remove this when MinGW incorporates them. */
 #define HWND_MESSAGE                ((HWND)-3)
     unsigned int curbufsize;
     unsigned int frame_num;
     char *video_size;       /**< A string describing video size, set by a private option. */
+    char *framerate;        /**< Set by a private option. */
 };
 static enum PixelFormat vfw_pixfmt(DWORD biCompression, WORD biBitCount)
 static void dump_videohdr(AVFormatContext *s, VIDEOHDR *vhdr)
 {
-#ifdef DEBUG_VFW
+#ifdef DEBUG
     av_log(s, AV_LOG_DEBUG, "VIDEOHDR\n");
     dstruct(s, vhdr, lpData, "p");
     dstruct(s, vhdr, dwBufferLength, "lu");
     }
     av_freep(&ctx->video_size);
+    av_freep(&ctx->framerate);
     return 0;
 }
     DWORD biCompression;
     WORD biBitCount;
     int ret;
+    AVRational fps;
     if (!strcmp(s->filename, "list")) {
         for (devnum = 0; devnum <= 9; devnum++) {
         return AVERROR(EIO);
     }
-    if(!ap->time_base.den) {
+#if FF_API_FORMAT_PARAMETERS
-        av_log(s, AV_LOG_ERROR, "A time base must be specified.\n");
+    if (ap->time_base.num)
-        return AVERROR(EIO);
+        fps = (AVRational){ap->time_base.den, ap->time_base.num};
-    }
+#endif
     ctx->hwnd = capCreateCaptureWindow(NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, 0);
     if(!ctx->hwnd) {
     cparms.fYield = 1; // Spawn a background thread
     cparms.dwRequestMicroSecPerFrame =
-                               (ap->time_base.num*1000000) / ap->time_base.den;
+                               (fps.den*1000000) / fps.num;
     cparms.fAbortLeftMouse = 0;
     cparms.fAbortRightMouse = 0;
     cparms.fCaptureAudio = 0;
         goto fail_io;
     codec = st->codec;
-    codec->time_base = ap->time_base;
+    codec->time_base = (AVRational){fps.den, fps.num};
     codec->codec_type = AVMEDIA_TYPE_VIDEO;
     codec->width  = bi->bmiHeader.biWidth;
     codec->height = bi->bmiHeader.biHeight;
 #define DEC AV_OPT_FLAG_DECODING_PARAM
 static const AVOption options[] = {
     { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), FF_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
+    { "framerate", "", OFFSET(framerate), FF_OPT_TYPE_STRING, {.str = "ntsc"}, 0, 0, DEC },
     { NULL },
 };

libavformat/4xm.c+2−2

@@ -246,7 +246,7 @@ static int fourxm_read_packet(AVFormatContext *s, · 245 unmodified lines
246	FourxmDemuxContext *fourxm = s->priv_data;	246	FourxmDemuxContext *fourxm = s->priv_data;
247	AVIOContext *pb = s->pb;	247	AVIOContext *pb = s->pb;
248	unsigned int fourcc_tag;	248	unsigned int fourcc_tag;
249	unsigned int size, out_size av_unused;	249	unsigned int size;
250	int ret = 0;	250	int ret = 0;
251	unsigned int track_number;	251	unsigned int track_number;
252	int packet_read = 0;	252	int packet_read = 0;
@@ -295,7 +295,7 @@ static int fourxm_read_packet(AVFormatContext *s, · 42 unmodified lines
295		295
296	case snd__TAG:	296	case snd__TAG:
297	track_number = avio_rl32(pb);	297	track_number = avio_rl32(pb);
298	out_size= avio_rl32(pb);	298	avio_skip(pb, 4);
299	size-=8;	299	size-=8;
300		300
301	if (track_number < fourxm->track_count && fourxm->tracks[track_number].channels>0) {	301	if (track_number < fourxm->track_count && fourxm->tracks[track_number].channels>0) {

libavformat/ape.c+1−3

 #include "avformat.h"
 #include "apetag.h"
-#define ENABLE_DEBUG 0
 /* The earliest and latest file formats supported by this library */
 #define APE_MIN_VERSION 3950
 #define APE_MAX_VERSION 3990
 static void ape_dumpinfo(AVFormatContext * s, APEContext * ape_ctx)
 {
-#if ENABLE_DEBUG
+#ifdef DEBUG
     int i;
     av_log(s, AV_LOG_DEBUG, "Descriptor Block:\n\n");

libavformat/apetag.c+2−4

 #include "avformat.h"
 #include "apetag.h"
-#define ENABLE_DEBUG 0
 #define APE_TAG_VERSION               2000
 #define APE_TAG_FOOTER_BYTES          32
 #define APE_TAG_FLAG_CONTAINS_HEADER  (1 << 31)
 {
     AVIOContext *pb = s->pb;
     uint8_t key[1024], *value;
-    uint32_t size, flags av_unused;
+    uint32_t size;
     int i, c;
     size = avio_rl32(pb);  /* field size */
-    flags = avio_rl32(pb); /* field flags */
+    avio_skip(pb, 4);      /* field flags */
     for (i = 0; i < sizeof(key) - 1; i++) {
         c = avio_r8(pb);
         if (c < 0x20 || c > 0x7E)

libavformat/asfdec.c+8−11

     ff_asf_guid g;
     enum AVMediaType type;
     int type_specific_size, sizeX;
-    uint64_t total_size av_unused;
     unsigned int tag1;
     int64_t pos1, pos2, start_time;
     int test_for_ext_stream_audio, is_dvr_ms_audio=0;
         return -1;
     }
     ff_get_guid(pb, &g);
-    total_size = avio_rl64(pb);
+    avio_skip(pb, 8); /* total_size */
     type_specific_size = avio_rl32(pb);
     avio_rl32(pb);
     st->id = avio_rl16(pb) & 0x7f; /* stream id */
     AVIOContext *pb = s->pb;
     ff_asf_guid g;
     int ext_len, payload_ext_ct, stream_ct, i;
-    uint32_t ext_d av_unused, leak_rate, stream_num;
+    uint32_t leak_rate, stream_num;
     unsigned int stream_languageid_index;
     avio_rl64(pb); // starttime
     for (i=0; i<payload_ext_ct; i++){
         ff_get_guid(pb, &g);
-        ext_d=avio_rl16(pb);
+        avio_skip(pb, 2);
         ext_len=avio_rl32(pb);
         avio_skip(pb, ext_len);
     }
 {
     AVIOContext *pb = s->pb;
     ASFContext *asf = s->priv_data;
-    int n, stream_num, name_len, value_len, value_type av_unused, value_num;
+    int n, stream_num, name_len, value_len, value_num;
     int ret, i;
     n = avio_rl16(pb);
         avio_rl16(pb); //lang_list_index
         stream_num= avio_rl16(pb);
         name_len=   avio_rl16(pb);
-        value_type= avio_rl16(pb);
+        avio_skip(pb, 2); /* value_type */
         value_len=  avio_rl32(pb);
         if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
             // if so the next iteration will pick it up
             continue;
         } else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
-            av_unused int v1, v2;
             ff_get_guid(pb, &g);
-            v1 = avio_rl32(pb);
+            avio_skip(pb, 6);
-            v2 = avio_rl16(pb);
             continue;
         } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
             asf_read_marker(s, gsize);
     ASFContext *asf = s->priv_data;
     int rsize = 1;
     int num = avio_r8(pb);
-    int64_t ts0, ts1 av_unused;
+    int64_t ts0;
     asf->packet_segments--;
     asf->packet_key_frame = num >> 7;
 //            av_log(s, AV_LOG_DEBUG, "\n");
             avio_skip(pb, 10);
             ts0= avio_rl64(pb);
-            ts1= avio_rl64(pb);
+            avio_skip(pb, 8);;
             avio_skip(pb, 12);
             avio_rl32(pb);
             avio_skip(pb, asf->packet_replic_size - 8 - 38 - 4);

libavformat/gif.c+0−4

                            AVCodecContext *enc, const uint8_t *buf, int size)
 {
     AVIOContext *pb = s->pb;
-    GIFContext *gif = s->priv_data;
     int jiffies;
-    int64_t delay;
     /* graphic control extension block */
     avio_w8(pb, 0x21);
     /* 1 jiffy is 1/70 s */
     /* the delay_time field indicates the number of jiffies - 1 */
-    delay = gif->file_time - gif->time;
     /* XXX: should use delay, in order to be more accurate */
     /* instead of using the same rounded value each time */
     /* XXX: don't even remember if I really use it for now */

libavformat/ipmovie.c+46−58

 #include "libavutil/intreadwrite.h"
 #include "avformat.h"
-/* debugging support: #define DEBUG_IPMOVIE as non-zero to see extremely
- * verbose information about the demux process */
-#define DEBUG_IPMOVIE 0
-#if DEBUG_IPMOVIE
-#undef printf
-#define debug_ipmovie printf
-#else
-static inline void debug_ipmovie(const char *format, ...) { }
-#endif
 #define CHUNK_PREAMBLE_SIZE 4
 #define OPCODE_PREAMBLE_SIZE 4
             s->audio_frame_count +=
                 (s->audio_chunk_size - 6) / s->audio_channels;
-        debug_ipmovie("sending audio frame with pts %"PRId64" (%d audio frames)\n",
+        av_dlog(NULL, "sending audio frame with pts %"PRId64" (%d audio frames)\n",
-            pkt->pts, s->audio_frame_count);
+                pkt->pts, s->audio_frame_count);
         chunk_type = CHUNK_VIDEO;
         pkt->stream_index = s->video_stream_index;
         pkt->pts = s->video_pts;
-        debug_ipmovie("sending video frame with pts %"PRId64"\n",
+        av_dlog(NULL, "sending video frame with pts %"PRId64"\n", pkt->pts);
-            pkt->pts);
         s->video_pts += s->frame_pts_inc;
     chunk_size = AV_RL16(&chunk_preamble[0]);
     chunk_type = AV_RL16(&chunk_preamble[2]);
-    debug_ipmovie("chunk type 0x%04X, 0x%04X bytes: ", chunk_type, chunk_size);
+    av_dlog(NULL, "chunk type 0x%04X, 0x%04X bytes: ", chunk_type, chunk_size);
     switch (chunk_type) {
     case CHUNK_INIT_AUDIO:
-        debug_ipmovie("initialize audio\n");
+        av_dlog(NULL, "initialize audio\n");
         break;
     case CHUNK_AUDIO_ONLY:
-        debug_ipmovie("audio only\n");
+        av_dlog(NULL, "audio only\n");
         break;
     case CHUNK_INIT_VIDEO:
-        debug_ipmovie("initialize video\n");
+        av_dlog(NULL, "initialize video\n");
         break;
     case CHUNK_VIDEO:
-        debug_ipmovie("video (and audio)\n");
+        av_dlog(NULL, "video (and audio)\n");
         break;
     case CHUNK_SHUTDOWN:
-        debug_ipmovie("shutdown\n");
+        av_dlog(NULL, "shutdown\n");
         break;
     case CHUNK_END:
-        debug_ipmovie("end\n");
+        av_dlog(NULL, "end\n");
         break;
     default:
-        debug_ipmovie("invalid chunk\n");
+        av_dlog(NULL, "invalid chunk\n");
         chunk_type = CHUNK_BAD;
         break;
         chunk_size -= OPCODE_PREAMBLE_SIZE;
         chunk_size -= opcode_size;
         if (chunk_size < 0) {
-            debug_ipmovie("chunk_size countdown just went negative\n");
+            av_dlog(NULL, "chunk_size countdown just went negative\n");
             chunk_type = CHUNK_BAD;
             break;
         }
-        debug_ipmovie("  opcode type %02X, version %d, 0x%04X bytes: ",
+        av_dlog(NULL, "  opcode type %02X, version %d, 0x%04X bytes: ",
-            opcode_type, opcode_version, opcode_size);
+                opcode_type, opcode_version, opcode_size);
         switch (opcode_type) {
         case OPCODE_END_OF_STREAM:
-            debug_ipmovie("end of stream\n");
+            av_dlog(NULL, "end of stream\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_END_OF_CHUNK:
-            debug_ipmovie("end of chunk\n");
+            av_dlog(NULL, "end of chunk\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_CREATE_TIMER:
-            debug_ipmovie("create timer\n");
+            av_dlog(NULL, "create timer\n");
             if ((opcode_version > 0) || (opcode_size > 6)) {
-                debug_ipmovie("bad create_timer opcode\n");
+                av_dlog(NULL, "bad create_timer opcode\n");
                 chunk_type = CHUNK_BAD;
                 break;
             }
                 break;
             }
             s->frame_pts_inc = ((uint64_t)AV_RL32(&scratch[0])) * AV_RL16(&scratch[4]);
-            debug_ipmovie("  %.2f frames/second (timer div = %d, subdiv = %d)\n",
+            av_dlog(NULL, "  %.2f frames/second (timer div = %d, subdiv = %d)\n",
-                1000000.0/s->frame_pts_inc, AV_RL32(&scratch[0]), AV_RL16(&scratch[4]));
+                    1000000.0 / s->frame_pts_inc, AV_RL32(&scratch[0]),
+                    AV_RL16(&scratch[4]));
             break;
         case OPCODE_INIT_AUDIO_BUFFERS:
-            debug_ipmovie("initialize audio buffers\n");
+            av_dlog(NULL, "initialize audio buffers\n");
             if ((opcode_version > 1) || (opcode_size > 10)) {
-                debug_ipmovie("bad init_audio_buffers opcode\n");
+                av_dlog(NULL, "bad init_audio_buffers opcode\n");
                 chunk_type = CHUNK_BAD;
                 break;
             }
                 s->audio_type = CODEC_ID_PCM_S16LE;
             else
                 s->audio_type = CODEC_ID_PCM_U8;
-            debug_ipmovie("audio: %d bits, %d Hz, %s, %s format\n",
+            av_dlog(NULL, "audio: %d bits, %d Hz, %s, %s format\n",
-                s->audio_bits,
+                    s->audio_bits, s->audio_sample_rate,
-                s->audio_sample_rate,
+                    (s->audio_channels == 2) ? "stereo" : "mono",
-                (s->audio_channels == 2) ? "stereo" : "mono",
+                    (s->audio_type == CODEC_ID_INTERPLAY_DPCM) ?
-                (s->audio_type == CODEC_ID_INTERPLAY_DPCM) ?
+                    "Interplay audio" : "PCM");
-                "Interplay audio" : "PCM");
             break;
         case OPCODE_START_STOP_AUDIO:
-            debug_ipmovie("start/stop audio\n");
+            av_dlog(NULL, "start/stop audio\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_INIT_VIDEO_BUFFERS:
-            debug_ipmovie("initialize video buffers\n");
+            av_dlog(NULL, "initialize video buffers\n");
             if ((opcode_version > 2) || (opcode_size > 8)) {
-                debug_ipmovie("bad init_video_buffers opcode\n");
+                av_dlog(NULL, "bad init_video_buffers opcode\n");
                 chunk_type = CHUNK_BAD;
                 break;
             }
             } else {
                 s->video_bpp = 16;
             }
-            debug_ipmovie("video resolution: %d x %d\n",
+            av_dlog(NULL, "video resolution: %d x %d\n",
-                s->video_width, s->video_height);
+                    s->video_width, s->video_height);
             break;
         case OPCODE_UNKNOWN_06:
         case OPCODE_UNKNOWN_13:
         case OPCODE_UNKNOWN_14:
         case OPCODE_UNKNOWN_15:
-            debug_ipmovie("unknown (but documented) opcode %02X\n", opcode_type);
+            av_dlog(NULL, "unknown (but documented) opcode %02X\n", opcode_type);
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_SEND_BUFFER:
-            debug_ipmovie("send buffer\n");
+            av_dlog(NULL, "send buffer\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_AUDIO_FRAME:
-            debug_ipmovie("audio frame\n");
+            av_dlog(NULL, "audio frame\n");
             /* log position and move on for now */
             s->audio_chunk_offset = avio_tell(pb);
             break;
         case OPCODE_SILENCE_FRAME:
-            debug_ipmovie("silence frame\n");
+            av_dlog(NULL, "silence frame\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_INIT_VIDEO_MODE:
-            debug_ipmovie("initialize video mode\n");
+            av_dlog(NULL, "initialize video mode\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_CREATE_GRADIENT:
-            debug_ipmovie("create gradient\n");
+            av_dlog(NULL, "create gradient\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_SET_PALETTE:
-            debug_ipmovie("set palette\n");
+            av_dlog(NULL, "set palette\n");
             /* check for the logical maximum palette size
              * (3 * 256 + 4 bytes) */
             if (opcode_size > 0x304) {
-                debug_ipmovie("demux_ipmovie: set_palette opcode too large\n");
+                av_dlog(NULL, "demux_ipmovie: set_palette opcode too large\n");
                 chunk_type = CHUNK_BAD;
                 break;
             }
             last_color = first_color + AV_RL16(&scratch[2]) - 1;
             /* sanity check (since they are 16 bit values) */
             if ((first_color > 0xFF) || (last_color > 0xFF)) {
-                debug_ipmovie("demux_ipmovie: set_palette indexes out of range (%d -> %d)\n",
+                av_dlog(NULL, "demux_ipmovie: set_palette indexes out of range (%d -> %d)\n",
                     first_color, last_color);
                 chunk_type = CHUNK_BAD;
                 break;
             break;
         case OPCODE_SET_PALETTE_COMPRESSED:
-            debug_ipmovie("set palette compressed\n");
+            av_dlog(NULL, "set palette compressed\n");
             avio_skip(pb, opcode_size);
             break;
         case OPCODE_SET_DECODING_MAP:
-            debug_ipmovie("set decoding map\n");
+            av_dlog(NULL, "set decoding map\n");
             /* log position and move on for now */
             s->decode_map_chunk_offset = avio_tell(pb);
             break;
         case OPCODE_VIDEO_DATA:
-            debug_ipmovie("set video data\n");
+            av_dlog(NULL, "set video data\n");
             /* log position and move on for now */
             s->video_chunk_offset = avio_tell(pb);
             break;
         default:
-            debug_ipmovie("*** unknown opcode type\n");
+            av_dlog(NULL, "*** unknown opcode type\n");
             chunk_type = CHUNK_BAD;
             break;

libavformat/mmf.c+2−2

@@ -186,13 +186,13 @@ static int mmf_read_header(AVFormatContext *s, · 185 unmodified lines
186	unsigned int tag;	186	unsigned int tag;
187	AVIOContext *pb = s->pb;	187	AVIOContext *pb = s->pb;
188	AVStream *st;	188	AVStream *st;
189	int64_t file_size av_unused, size;	189	int64_t size;
190	int rate, params;	190	int rate, params;
191		191
192	tag = avio_rl32(pb);	192	tag = avio_rl32(pb);
193	if (tag != MKTAG('M', 'M', 'M', 'D'))	193	if (tag != MKTAG('M', 'M', 'M', 'D'))
194	return -1;	194	return -1;
195	file_size = avio_rb32(pb);	195	avio_skip(pb, 4); /* file_size */
196		196
197	/* Skip some unused chunks that may or may not be present */	197	/* Skip some unused chunks that may or may not be present */
198	for(;; avio_skip(pb, size)) {	198	for(;; avio_skip(pb, size)) {

libavformat/mpeg.c+3−4

     pkt->dts = dts;
     pkt->pos = dummy_pos;
     pkt->stream_index = st->index;
-#if 0
+    av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n",
-    av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
+            pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
-           pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size);
+            pkt->size);
-#endif
     return 0;
 }

libavformat/mpegenc.c+2−4

                 best_dts= pkt_desc->dts;
         }
-#if 0
+        av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
-        av_log(ctx, AV_LOG_DEBUG, "bumping scr, scr:%f, dts:%f\n",
+                scr / 90000.0, best_dts / 90000.0);
-               scr/90000.0, best_dts/90000.0);
-#endif
         if(best_dts == INT64_MAX)
             return 0;

libavformat/mpegts.c+2−4

         s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
         st->codec->bit_rate = s->bit_rate;
         st->start_time = ts->cur_pcr;
-#if 0
+        av_dlog(ts->stream, "start=%0.3f pcr=%0.3f incr=%d\n",
-        av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n",
+                st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
-               st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
-#endif
     }
     avio_seek(pb, pos, SEEK_SET);

libavformat/nutdec.c+1−3

     uint64_t tmp, end;
     unsigned int stream_count;
     int i, j, tmp_stream, tmp_mul, tmp_pts, tmp_size, count, tmp_res, tmp_head_idx;
-    int64_t tmp_match;
     end= get_packetheader(nut, bc, 1, MAIN_STARTCODE);
     end += avio_tell(bc);
     tmp_pts=0;
     tmp_mul=1;
     tmp_stream=0;
-    tmp_match= 1-(1LL<<62);
     tmp_head_idx= 0;
     for(i=0; i<256;){
         int tmp_flags = ffio_read_varlen(bc);
         else             tmp_res   = 0;
         if(tmp_fields>5) count     = ffio_read_varlen(bc);
         else             count     = tmp_mul - tmp_size;
-        if(tmp_fields>6) tmp_match = get_s(bc);
+        if(tmp_fields>6) get_s(bc);
         if(tmp_fields>7) tmp_head_idx= ffio_read_varlen(bc);
         while(tmp_fields-- > 8)

libavformat/oggdec.c+1−6

     int flags, nsegs;
     uint64_t gp;
     uint32_t serial;
-    uint32_t seq av_unused;
-    uint32_t crc av_unused;
     int size, idx;
     uint8_t sync[4];
     int sp = 0;
     flags = avio_r8(bc);
     gp = avio_rl64 (bc);
     serial = avio_rl32 (bc);
-    seq = avio_rl32 (bc);
+    avio_skip(bc, 8); /* seq, crc */
-    crc = avio_rl32 (bc);
     nsegs = avio_r8(bc);
     idx = ogg_find_stream (ogg, serial);
         }
     }while (!complete);
-    av_dlog(s, "ogg_packet: idx %i, frame size %i, start %i\n",
-           idx, os->psize, os->pstart);
     if (os->granule == -1)
         av_log(s, AV_LOG_WARNING, "Page at %"PRId64" is missing granule\n", os->page_pos);

libavformat/oggparseogm.c+1−3

     const uint8_t *p = os->buf + os->pstart;
     uint64_t time_unit;
     uint64_t spu;
-    uint32_t default_len av_unused;
     if(!(*p & 1))
         return 0;
         time_unit   = bytestream_get_le64(&p);
         spu         = bytestream_get_le64(&p);
-        default_len = bytestream_get_le32(&p);
+        p += 4;                     /* default_len */
         p += 8;                     /* buffersize + bits_per_sample */
         if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){

libavformat/oma.c+2−0

@@ -80,6 +80,8 @@ static int oma_read_header(AVFormatContext *s, · 79 unmodified lines
80		80
81	ff_id3v2_read(s, ID3v2_EA3_MAGIC);	81	ff_id3v2_read(s, ID3v2_EA3_MAGIC);
82	ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);	82	ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);
		83	if (ret < EA3_HEADER_SIZE)
		84	return -1;
83		85
84	if (memcmp(buf, ((const uint8_t[]){'E', 'A', '3'}),3) \|\| buf[4] != 0 \|\| buf[5] != EA3_HEADER_SIZE) {	86	if (memcmp(buf, ((const uint8_t[]){'E', 'A', '3'}),3) \|\| buf[4] != 0 \|\| buf[5] != EA3_HEADER_SIZE) {
85	av_log(s, AV_LOG_ERROR, "Couldn't find the EA3 header !\n");	87	av_log(s, AV_LOG_ERROR, "Couldn't find the EA3 header !\n");

libavformat/rl2.c+2−4

     unsigned int audio_frame_counter = 0;
     unsigned int video_frame_counter = 0;
     unsigned int back_size;
-    int data_size av_unused;
-    unsigned short encoding_method av_unused;
     unsigned short sound_rate;
     unsigned short rate;
     unsigned short channels;
     avio_skip(pb,4);          /* skip FORM tag */
     back_size = avio_rl32(pb); /**< get size of the background frame */
     signature = avio_rb32(pb);
-    data_size = avio_rb32(pb);
+    avio_skip(pb, 4);         /* data size */
     frame_count = avio_rl32(pb);
     /* disallow back_sizes and frame_counts that may lead to overflows later */
     if(back_size > INT_MAX/2  || frame_count > INT_MAX / sizeof(uint32_t))
         return AVERROR_INVALIDDATA;
-    encoding_method = avio_rl16(pb);
+    avio_skip(pb, 2);         /* encoding mentod */
     sound_rate = avio_rl16(pb);
     rate = avio_rl16(pb);
     channels = avio_rl16(pb);

libavformat/rmdec.c+2−2

@@ -280,7 +280,7 @@ ff_rm_read_mdpr_codecdata (AVFormatContext s, AVIOContext pb, · 279 unmodified lines
280	if (rm_read_audio_stream_info(s, pb, st, rst, 0))	280	if (rm_read_audio_stream_info(s, pb, st, rst, 0))
281	return -1;	281	return -1;
282	} else {	282	} else {
283	int fps, fps2 av_unused;	283	int fps;
284	if (avio_rl32(pb) != MKTAG('V', 'I', 'D', 'O')) {	284	if (avio_rl32(pb) != MKTAG('V', 'I', 'D', 'O')) {
285	fail1:	285	fail1:
286	av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n");	286	av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n");
@@ -298,7 +298,7 @@ ff_rm_read_mdpr_codecdata (AVFormatContext s, AVIOContext pb, · 11 unmodified lines
298	fps= avio_rb16(pb);	298	fps= avio_rb16(pb);
299	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;	299	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
300	avio_rb32(pb);	300	avio_rb32(pb);
301	fps2= avio_rb16(pb);	301	avio_skip(pb, 2);
302	avio_rb16(pb);	302	avio_rb16(pb);
303		303
304	if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (avio_tell(pb) - codec_pos))) < 0)	304	if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (avio_tell(pb) - codec_pos))) < 0)

libavformat/rpl.c+2−2

@@ -299,9 +299,9 @@ static int rpl_read_packet(AVFormatContext s, AVPacket pkt) · 298 unmodified lines
299	stream->codec->codec_tag == 124) {	299	stream->codec->codec_tag == 124) {
300	// We have to split Escape 124 frames because there are	300	// We have to split Escape 124 frames because there are
301	// multiple frames per chunk in Escape 124 samples.	301	// multiple frames per chunk in Escape 124 samples.
302	uint32_t frame_size, frame_flags av_unused;	302	uint32_t frame_size;
303		303
304	frame_flags = avio_rl32(pb);	304	avio_skip(pb, 4); /* flags */
305	frame_size = avio_rl32(pb);	305	frame_size = avio_rl32(pb);
306	if (avio_seek(pb, -8, SEEK_CUR) < 0)	306	if (avio_seek(pb, -8, SEEK_CUR) < 0)
307	return AVERROR(EIO);	307	return AVERROR(EIO);

libavformat/rtpdec_latm.c+2−3

     int len = ff_hex_to_data(NULL, value), i, ret = 0;
     GetBitContext gb;
     uint8_t *config;
-    int audio_mux_version, same_time_framing, num_sub_frames av_unused,
+    int audio_mux_version, same_time_framing, num_programs, num_layers;
-        num_programs, num_layers;
     /* Pad this buffer, too, to avoid out of bounds reads with get_bits below */
     config = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
     init_get_bits(&gb, config, len*8);
     audio_mux_version = get_bits(&gb, 1);
     same_time_framing = get_bits(&gb, 1);
-    num_sub_frames    = get_bits(&gb, 6);
+    skip_bits(&gb, 6); /* num_sub_frames */
     num_programs      = get_bits(&gb, 4);
     num_layers        = get_bits(&gb, 3);
     if (audio_mux_version != 0 || same_time_framing != 1 || num_programs != 0 ||

libavformat/rtsp.c+0−3

 #include "url.h"
 //#define DEBUG
-//#define DEBUG_RTP_TCP
 /* Timeout values for socket poll, in ms,
  * and read_packet(), in seconds  */
         q = buf;
         for (;;) {
             ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
-#ifdef DEBUG_RTP_TCP
             av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
-#endif
             if (ret != 1)
                 return AVERROR_EOF;
             if (ch == '\n')

libavformat/sauce.c+2−2

@@ -32,7 +32,7 @@ int ff_sauce_read(AVFormatContext avctx, uint64_t fsize, int *got_width, int g · 31 unmodified lines
32	{	32	{
33	AVIOContext *pb = avctx->pb;	33	AVIOContext *pb = avctx->pb;
34	char buf[36];	34	char buf[36];
35	int datatype, filetype, t1, t2, nb_comments, flags av_unused;	35	int datatype, filetype, t1, t2, nb_comments;
36	uint64_t start_pos = avio_size(pb) - 128;	36	uint64_t start_pos = avio_size(pb) - 128;
37		37
38	avio_seek(pb, start_pos, SEEK_SET);	38	avio_seek(pb, start_pos, SEEK_SET);
@@ -57,7 +57,7 @@ int ff_sauce_read(AVFormatContext avctx, uint64_t fsize, int *got_width, int g · 18 unmodified lines
57	t1 = avio_rl16(pb);	57	t1 = avio_rl16(pb);
58	t2 = avio_rl16(pb);	58	t2 = avio_rl16(pb);
59	nb_comments = avio_r8(pb);	59	nb_comments = avio_r8(pb);
60	flags = avio_r8(pb);	60	avio_skip(pb, 1); /* flags */
61	avio_skip(pb, 4);	61	avio_skip(pb, 4);
62	GET_SAUCE_META("encoder", 22);	62	GET_SAUCE_META("encoder", 22);
63		63

libavformat/sol.c+1−2

 static int sol_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
 {
-    int size av_unused;
     unsigned int magic,tag;
     AVIOContext *pb = s->pb;
     unsigned int id, channels, rate, type;
         return -1;
     rate = avio_rl16(pb);
     type = avio_r8(pb);
-    size = avio_rl32(pb);
+    avio_skip(pb, 4); /* size */
     if (magic != 0x0B8D)
         avio_r8(pb); /* newer SOLs contain padding byte */

tests/fate/h264.mak+102−102

tests/regression-funcs.sh+1−1

@@ -102,7 +102,7 @@ do_ffmpeg_crc() · 101 unmodified lines
102		102
103	do_video_decoding()	103	do_video_decoding()
104	{	104	{
105	do_ffmpeg $raw_dst $DEC_OPTS $1 -i $target_path/$file -f rawvideo $ENC_OPTS $2	105	do_ffmpeg $raw_dst $DEC_OPTS $1 -i $target_path/$file -f rawvideo $ENC_OPTS -vsync 0 $2
106	}	106	}
107		107
108	do_video_encoding()	108	do_video_encoding()

Merge remote-tracking branch 'qatar/master'

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code