[PATCH] v4l: 631: implemented the v4l2 mpeg api for blackbird cards

- Implemented the v4l2 mpeg api for blackbird cards.

Signed-off-by: Catalin Climov <catalin@climov.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@brturbo.com.br>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

drivers/media/video/cx88/cx88-blackbird.c

@@ -38,7 +38,7 @@ MODULE_AUTHOR("Jelle Foks <jelle@foks.8m.com>");
 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
 MODULE_LICENSE("GPL");
 
-static unsigned int mpegbufs = 8;
+static unsigned int mpegbufs = 32;
 module_param(mpegbufs,int,0644);
 MODULE_PARM_DESC(mpegbufs,"number of mpeg buffers, range 2-32");
 
@@ -683,84 +683,553 @@ DB* DVD | MPEG2 | 720x576PAL | CBR     | 600 :Good    | 6000 Kbps  | 25fps   | M
 =================================================================================================================
 *DB: "DirectBurn"
 */
-static void blackbird_codec_settings(struct cx8802_dev *dev)
+
+static struct blackbird_dnr default_dnr_params = {
+	.mode     = BLACKBIRD_DNR_BITS_MANUAL,
+	.type     = BLACKBIRD_MEDIAN_FILTER_DISABLED,
+	.spatial  = 0,
+	.temporal = 0
+};
+static struct v4l2_mpeg_compression default_mpeg_params = {
+	.st_type          = V4L2_MPEG_PS_2,
+	.st_bitrate       = {
+		.mode     = V4L2_BITRATE_CBR,
+		.min      = 0,
+		.target   = 0,
+		.max      = 0
+	},
+	.ts_pid_pmt       = 16,
+	.ts_pid_audio     = 260,
+	.ts_pid_video     = 256,
+	.ts_pid_pcr       = 259,
+	.ps_size          = 0,
+	.au_type          = V4L2_MPEG_AU_2_II,
+	.au_bitrate       = {
+		.mode     = V4L2_BITRATE_CBR,
+		.min      = 224,
+		.target   = 224,
+		.max      = 224
+	},
+	.au_sample_rate    = 44100,
+	.au_pesid          = 0,
+	.vi_type           = V4L2_MPEG_VI_2,
+	.vi_aspect_ratio   = V4L2_MPEG_ASPECT_4_3,
+	.vi_bitrate        = {
+		.mode      = V4L2_BITRATE_CBR,
+		.min       = 4000,
+		.target    = 4500,
+		.max       = 6000
+	},
+	.vi_frame_rate     = 25,
+	.vi_frames_per_gop = 15,
+	.vi_bframes_count  = 2,
+	.vi_pesid          = 0,
+	.closed_gops       = 0,
+	.pulldown          = 0
+};
+
+static enum blackbird_stream_type mpeg_stream_types[] = {
+	[V4L2_MPEG_SS_1]   = BLACKBIRD_STREAM_MPEG1,
+	[V4L2_MPEG_PS_2]   = BLACKBIRD_STREAM_PROGRAM,
+	[V4L2_MPEG_TS_2]   = BLACKBIRD_STREAM_TRANSPORT,
+	[V4L2_MPEG_PS_DVD] = BLACKBIRD_STREAM_DVD,
+};
+static enum blackbird_aspect_ratio mpeg_stream_ratios[] = {
+	[V4L2_MPEG_ASPECT_SQUARE] = BLACKBIRD_ASPECT_RATIO_1_1_SQUARE,
+	[V4L2_MPEG_ASPECT_4_3]    = BLACKBIRD_ASPECT_RATIO_4_3,
+	[V4L2_MPEG_ASPECT_16_9]   = BLACKBIRD_ASPECT_RATIO_16_9,
+	[V4L2_MPEG_ASPECT_1_221]  = BLACKBIRD_ASPECT_RATIO_221_100,
+};
+static enum blackbird_video_bitrate_type mpeg_video_bitrates[] = {
+	[V4L2_BITRATE_NONE] = BLACKBIRD_VIDEO_CBR,
+	[V4L2_BITRATE_CBR]  = BLACKBIRD_VIDEO_CBR,
+	[V4L2_BITRATE_VBR]  = BLACKBIRD_VIDEO_VBR,
+};
+/* find the best layer I/II bitrate to fit a given numeric value */
+struct bitrate_bits {
+	u32 bits; /* layer bits for the best fit */
+	u32 rate; /* actual numeric value for the layer best fit */
+};
+struct bitrate_approximation {
+	u32                 target;   /* numeric value of the rate we want */
+	struct bitrate_bits layer[2];
+};
+static struct bitrate_approximation mpeg_audio_bitrates[] = {
+	/* target  layer[0].bits           layer[0].rate       layer[1].bits           layer[1].rate */
+	{   0, { {                                0,   0, }, {                                0,   0, }, }, },
+	{  32, { { BLACKBIRD_AUDIO_BITS_LAYER_1_32 ,  32, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_32 ,  32, }, }, },
+	{  48, { { BLACKBIRD_AUDIO_BITS_LAYER_1_64 ,  64, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_48 ,  48, }, }, },
+	{  56, { { BLACKBIRD_AUDIO_BITS_LAYER_1_64 ,  64, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_56 ,  56, }, }, },
+	{  64, { { BLACKBIRD_AUDIO_BITS_LAYER_1_64 ,  64, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_64 ,  64, }, }, },
+	{  80, { { BLACKBIRD_AUDIO_BITS_LAYER_1_96 ,  96, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_80 ,  80, }, }, },
+	{  96, { { BLACKBIRD_AUDIO_BITS_LAYER_1_96 ,  96, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_96 ,  96, }, }, },
+	{ 112, { { BLACKBIRD_AUDIO_BITS_LAYER_1_128, 128, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_112, 112, }, }, },
+	{ 128, { { BLACKBIRD_AUDIO_BITS_LAYER_1_128, 128, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_128, 128, }, }, },
+	{ 160, { { BLACKBIRD_AUDIO_BITS_LAYER_1_160, 160, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_160, 160, }, }, },
+	{ 192, { { BLACKBIRD_AUDIO_BITS_LAYER_1_192, 192, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_192, 192, }, }, },
+	{ 224, { { BLACKBIRD_AUDIO_BITS_LAYER_1_224, 224, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_224, 224, }, }, },
+	{ 256, { { BLACKBIRD_AUDIO_BITS_LAYER_1_256, 256, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_256, 256, }, }, },
+	{ 288, { { BLACKBIRD_AUDIO_BITS_LAYER_1_288, 288, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_320, 320, }, }, },
+	{ 320, { { BLACKBIRD_AUDIO_BITS_LAYER_1_320, 320, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_320, 320, }, }, },
+	{ 352, { { BLACKBIRD_AUDIO_BITS_LAYER_1_352, 352, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
+	{ 384, { { BLACKBIRD_AUDIO_BITS_LAYER_1_384, 384, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
+	{ 416, { { BLACKBIRD_AUDIO_BITS_LAYER_1_416, 416, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
+	{ 448, { { BLACKBIRD_AUDIO_BITS_LAYER_1_448, 448, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
+};
+static const int BITRATES_SIZE = ARRAY_SIZE(mpeg_audio_bitrates);
+
+static void blackbird_set_default_params(struct cx8802_dev *dev)
 {
-	int bitrate_mode = 1;
-	int bitrate = 7500000;
-	int bitrate_peak = 7500000;
-	bitrate_mode = BLACKBIRD_VIDEO_CBR;
-	bitrate = 4000*1024;
-	bitrate_peak = 4000*1024;
+	struct v4l2_mpeg_compression *params = &dev->params;
 
 	/* assign stream type */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_STREAM_TYPE, 1, 0, BLACKBIRD_STREAM_PROGRAM);
-
-	/* assign output port */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_OUTPUT_PORT, 1, 0, BLACKBIRD_OUTPUT_PORT_STREAMING); /* Host */
+	if( params->st_type >= ARRAY_SIZE(mpeg_stream_types) )
+		params->st_type = V4L2_MPEG_PS_2;
+	if( params->st_type == V4L2_MPEG_SS_1 )
+		params->vi_type = V4L2_MPEG_VI_1;
+	else
+		params->vi_type = V4L2_MPEG_VI_2;
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_STREAM_TYPE, 1, 0, mpeg_stream_types[params->st_type]);
 
 	/* assign framerate */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_PAL_25);
-
-	/* assign frame size */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_RESOLUTION, 2, 0,
-			  dev->height, dev->width);
+	if( params->vi_frame_rate <= 25 )
+	{
+		params->vi_frame_rate = 25;
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_PAL_25);
+	}
+	else
+	{
+		params->vi_frame_rate = 30;
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_NTSC_30);
+	}
 
 	/* assign aspect ratio */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_ASPECT_RATIO, 1, 0, BLACKBIRD_ASPECT_RATIO_4_3);
-
-	/* assign bitrates */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_VIDEO_BITRATE, 5, 0,
-			 bitrate_mode,         /* mode */
-			 bitrate,              /* bps */
-			 bitrate_peak / BLACKBIRD_PEAK_RATE_DIVISOR,   /* peak/400 */
-			 BLACKBIRD_MUX_RATE_DEFAULT /*, 0x70*/);             /* encoding buffer, ckennedy */
+	if( params->vi_aspect_ratio >= ARRAY_SIZE(mpeg_stream_ratios) )
+		params->vi_aspect_ratio = V4L2_MPEG_ASPECT_4_3;
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_ASPECT_RATIO, 1, 0, mpeg_stream_ratios[params->vi_aspect_ratio]);
 
 	/* assign gop properties */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_STRUCTURE, 2, 0, 15, 3);
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_STRUCTURE, 2, 0, params->vi_frames_per_gop, params->vi_bframes_count+1);
+
+	/* assign gop closure */
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_CLOSURE, 1, 0, params->closed_gops);
 
 	/* assign 3 2 pulldown */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_3_2_PULLDOWN, 1, 0, BLACKBIRD_3_2_PULLDOWN_DISABLED);
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_3_2_PULLDOWN, 1, 0, params->pulldown);
+
+	/* make sure the params are within bounds */
+	if( params->st_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
+		params->vi_bitrate.mode = V4L2_BITRATE_NONE;
+	if( params->vi_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
+		params->vi_bitrate.mode = V4L2_BITRATE_NONE;
+	if( params->au_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
+		params->au_bitrate.mode = V4L2_BITRATE_NONE;
 
 	/* assign audio properties */
 	/* note: it's not necessary to set the samplerate, the mpeg encoder seems to autodetect/adjust */
-	/* blackbird_api_cmd(dev, IVTV_API_ASSIGN_AUDIO_PROPERTIES, 1, 0, (2<<2) | (8<<4));
-	   blackbird_api_cmd(dev, IVTV_API_ASSIGN_AUDIO_PROPERTIES, 1, 0, 0 | (2 << 2) | (14 << 4)); */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_AUDIO_PARAMS, 1, 0,
-			BLACKBIRD_AUDIO_BITS_44100HZ |
-			BLACKBIRD_AUDIO_BITS_LAYER_2 |
-			BLACKBIRD_AUDIO_BITS_LAYER_2_224 |
-			BLACKBIRD_AUDIO_BITS_STEREO |
+	u32 au_params = BLACKBIRD_AUDIO_BITS_STEREO |
 			/* BLACKBIRD_AUDIO_BITS_BOUND_4 | */
 			BLACKBIRD_AUDIO_BITS_EMPHASIS_NONE |
 			BLACKBIRD_AUDIO_BITS_CRC_OFF |
 			BLACKBIRD_AUDIO_BITS_COPYRIGHT_OFF |
-			BLACKBIRD_AUDIO_BITS_COPY
-		);
+			BLACKBIRD_AUDIO_BITS_COPY |
+			0;
+	if( params->au_sample_rate <= 32000 )
+	{
+		params->au_sample_rate = 32000;
+		au_params |= BLACKBIRD_AUDIO_BITS_32000HZ;
+	}
+	else if( params->au_sample_rate <= 44100 )
+	{
+		params->au_sample_rate = 44100;
+		au_params |= BLACKBIRD_AUDIO_BITS_44100HZ;
+	}
+	else
+	{
+		params->au_sample_rate = 48000;
+		au_params |= BLACKBIRD_AUDIO_BITS_48000HZ;
+	}
+	if( params->au_type == V4L2_MPEG_AU_2_I )
+	{
+		au_params |= BLACKBIRD_AUDIO_BITS_LAYER_1;
+	}
+	else
+	{
+		/* TODO: try to handle the other formats more gracefully */
+		params->au_type = V4L2_MPEG_AU_2_II;
+		au_params |= BLACKBIRD_AUDIO_BITS_LAYER_2;
+	}
+	if( params->au_bitrate.mode )
+	{
+		if( params->au_bitrate.mode == V4L2_BITRATE_CBR )
+			params->au_bitrate.max = params->vi_bitrate.target;
+		else
+			params->au_bitrate.target = params->vi_bitrate.max;
+
+		int layer = params->au_type;
+		if( params->au_bitrate.target == 0 )
+		{
+			/* TODO: use the minimum possible bitrate instead of 0 ? */
+			au_params |= 0;
+		}
+		else if( params->au_bitrate.target >=
+		         mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate )
+		{
+			/* clamp the bitrate to the max supported by the standard */
+			params->au_bitrate.target = mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate;
+			params->au_bitrate.max = params->au_bitrate.target;
+			au_params |= mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].bits;
+		}
+		else
+		{
+			/* round up to the nearest supported bitrate */
+			int i;
+			for(i = 1; i < BITRATES_SIZE; i++)
+			{
+				if( params->au_bitrate.target > mpeg_audio_bitrates[i-1].layer[layer].rate &&
+				    params->au_bitrate.target <= mpeg_audio_bitrates[i].layer[layer].rate )
+				{
+					params->au_bitrate.target = mpeg_audio_bitrates[i].layer[layer].rate;
+					params->au_bitrate.max = params->au_bitrate.target;
+					au_params |= mpeg_audio_bitrates[i].layer[layer].bits;
+					break;
+				}
+			}
+		}
+	}
+	else
+	{
+		/* TODO: ??? */
+		params->au_bitrate.target = params->au_bitrate.max = 0;
+		au_params |= 0;
+	}
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_AUDIO_PARAMS, 1, 0, au_params );
+
+	/* assign bitrates */
+	if( params->vi_bitrate.mode )
+	{
+		/* bitrate is set, let's figure out the cbr/vbr mess */
+		if( params->vi_bitrate.max < params->vi_bitrate.target )
+		{
+			if( params->vi_bitrate.mode == V4L2_BITRATE_CBR )
+				params->vi_bitrate.max = params->vi_bitrate.target;
+			else
+				params->vi_bitrate.target = params->vi_bitrate.max;
+		}
+	}
+	else
+	{
+		if( params->st_bitrate.max < params->st_bitrate.target )
+		{
+			if( params->st_bitrate.mode == V4L2_BITRATE_VBR )
+				params->st_bitrate.target = params->st_bitrate.max;
+			else
+				params->st_bitrate.max = params->st_bitrate.target;
+		}
+		/* calculate vi_bitrate = st_bitrate - au_bitrate */
+		params->vi_bitrate.max = params->st_bitrate.max - params->au_bitrate.max;
+		params->vi_bitrate.target = params->st_bitrate.target - params->au_bitrate.target;
+	}
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_VIDEO_BITRATE, 4, 0,
+				mpeg_video_bitrates[params->vi_bitrate.mode],
+				params->vi_bitrate.target * 1000, /* kbps -> bps */
+				params->vi_bitrate.max * 1000 / BLACKBIRD_PEAK_RATE_DIVISOR, /* peak/400 */
+				BLACKBIRD_MUX_RATE_DEFAULT /*, 0x70*/); /* encoding buffer, ckennedy */
+
+	/* TODO: implement the stream ID stuff:
+		ts_pid_pmt, ts_pid_audio, ts_pid_video, ts_pid_pcr,
+		ps_size, au_pesid, vi_pesid
+ 	*/
+}
+#define CHECK_PARAM( name ) ( dev->params.name != params->name )
+#define IF_PARAM( name ) if( CHECK_PARAM( name ) )
+#define UPDATE_PARAM( name ) dev->params.name = params->name
+void blackbird_set_params(struct cx8802_dev *dev, struct v4l2_mpeg_compression *params)
+{
+	/* assign stream type */
+	if( params->st_type >= ARRAY_SIZE(mpeg_stream_types) )
+		params->st_type = V4L2_MPEG_PS_2;
+	if( params->st_type == V4L2_MPEG_SS_1 )
+		params->vi_type = V4L2_MPEG_VI_1;
+	else
+		params->vi_type = V4L2_MPEG_VI_2;
+	if( CHECK_PARAM( st_type ) || CHECK_PARAM( vi_type ) )
+	{
+		UPDATE_PARAM( st_type );
+		UPDATE_PARAM( vi_type );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_STREAM_TYPE, 1, 0, mpeg_stream_types[params->st_type]);
+	}
+
+	/* assign framerate */
+	if( params->vi_frame_rate <= 25 )
+		params->vi_frame_rate = 25;
+	else
+		params->vi_frame_rate = 30;
+	IF_PARAM( vi_frame_rate )
+	{
+		UPDATE_PARAM( vi_frame_rate );
+		if( params->vi_frame_rate == 25 )
+			blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_PAL_25);
+		else
+			blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_NTSC_30);
+	}
+
+	/* assign aspect ratio */
+	if( params->vi_aspect_ratio >= ARRAY_SIZE(mpeg_stream_ratios) )
+		params->vi_aspect_ratio = V4L2_MPEG_ASPECT_4_3;
+	IF_PARAM( vi_aspect_ratio )
+	{
+		UPDATE_PARAM( vi_aspect_ratio );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_ASPECT_RATIO, 1, 0, mpeg_stream_ratios[params->vi_aspect_ratio]);
+	}
+
+	/* assign gop properties */
+	if( CHECK_PARAM( vi_frames_per_gop ) || CHECK_PARAM( vi_bframes_count ) )
+	{
+		UPDATE_PARAM( vi_frames_per_gop );
+		UPDATE_PARAM( vi_bframes_count );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_STRUCTURE, 2, 0, params->vi_frames_per_gop, params->vi_bframes_count+1);
+	}
 
 	/* assign gop closure */
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_CLOSURE, 1, 0, BLACKBIRD_GOP_CLOSURE_OFF);
+	IF_PARAM( closed_gops )
+	{
+		UPDATE_PARAM( closed_gops );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_CLOSURE, 1, 0, params->closed_gops);
+	}
+
+	/* assign 3 2 pulldown */
+	IF_PARAM( pulldown )
+	{
+		UPDATE_PARAM( pulldown );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_3_2_PULLDOWN, 1, 0, params->pulldown);
+	}
+
+	/* make sure the params are within bounds */
+	if( params->st_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
+		params->vi_bitrate.mode = V4L2_BITRATE_NONE;
+	if( params->vi_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
+		params->vi_bitrate.mode = V4L2_BITRATE_NONE;
+	if( params->au_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
+		params->au_bitrate.mode = V4L2_BITRATE_NONE;
+
+	/* assign audio properties */
+	/* note: it's not necessary to set the samplerate, the mpeg encoder seems to autodetect/adjust */
+	u32 au_params = BLACKBIRD_AUDIO_BITS_STEREO |
+			/* BLACKBIRD_AUDIO_BITS_BOUND_4 | */
+	BLACKBIRD_AUDIO_BITS_EMPHASIS_NONE |
+		BLACKBIRD_AUDIO_BITS_CRC_OFF |
+		BLACKBIRD_AUDIO_BITS_COPYRIGHT_OFF |
+		BLACKBIRD_AUDIO_BITS_COPY |
+		0;
+	if( params->au_sample_rate < 32000 )
+	{
+		params->au_sample_rate = 32000;
+		au_params |= BLACKBIRD_AUDIO_BITS_32000HZ;
+	}
+	else if( params->au_sample_rate < 44100 )
+	{
+		params->au_sample_rate = 44100;
+		au_params |= BLACKBIRD_AUDIO_BITS_44100HZ;
+	}
+	else
+	{
+		params->au_sample_rate = 48000;
+		au_params |= BLACKBIRD_AUDIO_BITS_48000HZ;
+	}
+	if( params->au_type == V4L2_MPEG_AU_2_I )
+	{
+		au_params |= BLACKBIRD_AUDIO_BITS_LAYER_1;
+	}
+	else
+	{
+		/* TODO: try to handle the other formats more gracefully */
+		params->au_type = V4L2_MPEG_AU_2_II;
+		au_params |= BLACKBIRD_AUDIO_BITS_LAYER_2;
+	}
+	if( params->au_bitrate.mode )
+	{
+		if( params->au_bitrate.mode == V4L2_BITRATE_CBR )
+			params->au_bitrate.max = params->vi_bitrate.target;
+		else
+			params->au_bitrate.target = params->vi_bitrate.max;
 
+		int layer = params->au_type;
+		if( params->au_bitrate.target == 0 )
+		{
+			/* TODO: use the minimum possible bitrate instead of 0 ? */
+			au_params |= 0;
+		}
+		else if( params->au_bitrate.target >=
+		         mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate )
+		{
+			/* clamp the bitrate to the max supported by the standard */
+			params->au_bitrate.target = mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate;
+			params->au_bitrate.max = params->au_bitrate.target;
+			au_params |= mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].bits;
+		}
+		else
+		{
+			/* round up to the nearest supported bitrate */
+			int i;
+			for(i = 1; i < BITRATES_SIZE; i++)
+			{
+				if( params->au_bitrate.target > mpeg_audio_bitrates[i-1].layer[layer].rate &&
+				    params->au_bitrate.target <= mpeg_audio_bitrates[i].layer[layer].rate )
+				{
+					params->au_bitrate.target = mpeg_audio_bitrates[i].layer[layer].rate;
+					params->au_bitrate.max = params->au_bitrate.target;
+					au_params |= mpeg_audio_bitrates[i].layer[layer].bits;
+					break;
+				}
+			}
+		}
+	}
+	else
+	{
+		/* TODO: ??? */
+		params->au_bitrate.target = params->au_bitrate.max = 0;
+		au_params |= 0;
+	}
+	if( CHECK_PARAM( au_type ) || CHECK_PARAM( au_sample_rate )
+		|| CHECK_PARAM( au_bitrate.mode ) || CHECK_PARAM( au_bitrate.max )
+		|| CHECK_PARAM( au_bitrate.target )
+	)
+	{
+		UPDATE_PARAM( au_type );
+		UPDATE_PARAM( au_sample_rate );
+		UPDATE_PARAM( au_bitrate );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_AUDIO_PARAMS, 1, 0, au_params );
+	}
 
+	/* assign bitrates */
+	if( params->vi_bitrate.mode )
+	{
+		/* bitrate is set, let's figure out the cbr/vbr mess */
+		if( params->vi_bitrate.max < params->vi_bitrate.target )
+		{
+			if( params->vi_bitrate.mode == V4L2_BITRATE_CBR )
+				params->vi_bitrate.max = params->vi_bitrate.target;
+			else
+				params->vi_bitrate.target = params->vi_bitrate.max;
+		}
+	}
+	else
+	{
+		if( params->st_bitrate.max < params->st_bitrate.target )
+		{
+			if( params->st_bitrate.mode == V4L2_BITRATE_VBR )
+				params->st_bitrate.target = params->st_bitrate.max;
+			else
+				params->st_bitrate.max = params->st_bitrate.target;
+		}
+		/* calculate vi_bitrate = st_bitrate - au_bitrate */
+		params->vi_bitrate.max = params->st_bitrate.max - params->au_bitrate.max;
+		params->vi_bitrate.target = params->st_bitrate.target - params->au_bitrate.target;
+	}
+	UPDATE_PARAM( st_bitrate );
+	if( CHECK_PARAM( vi_bitrate.mode ) || CHECK_PARAM( vi_bitrate.max )
+		|| CHECK_PARAM( vi_bitrate.target )
+	)
+	{
+		UPDATE_PARAM( vi_bitrate );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_VIDEO_BITRATE, 4, 0,
+				mpeg_video_bitrates[params->vi_bitrate.mode],
+				params->vi_bitrate.target * 1000, /* kbps -> bps */
+				params->vi_bitrate.max * 1000 / BLACKBIRD_PEAK_RATE_DIVISOR, /* peak/400 */
+				BLACKBIRD_MUX_RATE_DEFAULT /*, 0x70*/); /* encoding buffer, ckennedy */
+	}
+
+	/* TODO: implement the stream ID stuff:
+		ts_pid_pmt, ts_pid_audio, ts_pid_video, ts_pid_pcr,
+		ps_size, au_pesid, vi_pesid
+ 	*/
+	UPDATE_PARAM( ts_pid_pmt );
+	UPDATE_PARAM( ts_pid_audio );
+	UPDATE_PARAM( ts_pid_video );
+	UPDATE_PARAM( ts_pid_pcr );
+	UPDATE_PARAM( ps_size );
+	UPDATE_PARAM( au_pesid );
+	UPDATE_PARAM( vi_pesid );
+}
+
+static void blackbird_set_default_dnr_params(struct cx8802_dev *dev)
+{
 	/* assign dnr filter mode */
+	if( dev->dnr_params.mode > BLACKBIRD_DNR_BITS_AUTO )
+		dev->dnr_params.mode = BLACKBIRD_DNR_BITS_MANUAL;
+	if( dev->dnr_params.type > BLACKBIRD_MEDIAN_FILTER_DIAGONAL )
+		dev->dnr_params.type = BLACKBIRD_MEDIAN_FILTER_DISABLED;
 	blackbird_api_cmd(dev, BLACKBIRD_API_SET_DNR_MODE, 2, 0,
-			BLACKBIRD_DNR_BITS_MANUAL,
-			BLACKBIRD_MEDIAN_FILTER_DISABLED
-		);
+				dev->dnr_params.mode,
+				dev->dnr_params.type
+			);
+
+	/* assign dnr filter props*/
+	if( dev->dnr_params.spatial > 15 )
+		dev->dnr_params.spatial = 15;
+	if( dev->dnr_params.temporal > 31 )
+		dev->dnr_params.temporal = 31;
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_MANUAL_DNR, 2, 0,
+				dev->dnr_params.spatial,
+				dev->dnr_params.temporal
+			);
+}
+#define CHECK_DNR_PARAM( name ) ( dev->dnr_params.name != dnr_params->name )
+#define UPDATE_DNR_PARAM( name ) dev->dnr_params.name = dnr_params->name
+void blackbird_set_dnr_params(struct cx8802_dev *dev, struct blackbird_dnr* dnr_params)
+{
+	/* assign dnr filter mode */
+	/* clamp values */
+	if( dnr_params->mode > BLACKBIRD_DNR_BITS_AUTO )
+		dnr_params->mode = BLACKBIRD_DNR_BITS_MANUAL;
+	if( dnr_params->type > BLACKBIRD_MEDIAN_FILTER_DIAGONAL )
+		dnr_params->type = BLACKBIRD_MEDIAN_FILTER_DISABLED;
+	/* check if the params actually changed */
+	if( CHECK_DNR_PARAM( mode ) || CHECK_DNR_PARAM( type ) )
+	{
+		UPDATE_DNR_PARAM( mode );
+		UPDATE_DNR_PARAM( type );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_DNR_MODE, 2, 0, dnr_params->mode, dnr_params->type);
+	}
 
 	/* assign dnr filter props*/
-	blackbird_api_cmd(dev, BLACKBIRD_API_SET_MANUAL_DNR, 2, 0, 0, 0);
+	if( dnr_params->spatial > 15 )
+		dnr_params->spatial = 15;
+	if( dnr_params->temporal > 31 )
+		dnr_params->temporal = 31;
+	if( CHECK_DNR_PARAM( spatial ) || CHECK_DNR_PARAM( temporal ) )
+	{
+		UPDATE_DNR_PARAM( spatial );
+		UPDATE_DNR_PARAM( temporal );
+		blackbird_api_cmd(dev, BLACKBIRD_API_SET_MANUAL_DNR, 2, 0, dnr_params->spatial, dnr_params->temporal);
+	}
+}
+
+static void blackbird_codec_settings(struct cx8802_dev *dev)
+{
+
+	/* assign output port */
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_OUTPUT_PORT, 1, 0, BLACKBIRD_OUTPUT_PORT_STREAMING); /* Host */
+
+	/* assign frame size */
+	blackbird_api_cmd(dev, BLACKBIRD_API_SET_RESOLUTION, 2, 0,
+				dev->height, dev->width);
 
 	/* assign coring levels (luma_h, luma_l, chroma_h, chroma_l) */
 	blackbird_api_cmd(dev, BLACKBIRD_API_SET_DNR_MEDIAN, 4, 0, 0, 255, 0, 255);
 
 	/* assign spatial filter type: luma_t: horiz_only, chroma_t: horiz_only */
 	blackbird_api_cmd(dev, BLACKBIRD_API_SET_SPATIAL_FILTER, 2, 0,
-			BLACKBIRD_SPATIAL_FILTER_LUMA_1D_HORIZ,
-			BLACKBIRD_SPATIAL_FILTER_CHROMA_1D_HORIZ
-		);
+				BLACKBIRD_SPATIAL_FILTER_LUMA_1D_HORIZ,
+				BLACKBIRD_SPATIAL_FILTER_CHROMA_1D_HORIZ
+			);
 
 	/* assign frame drop rate */
 	/* blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAME_DROP_RATE, 1, 0, 0); */
+
+	blackbird_set_default_params(dev);
+	blackbird_set_default_dnr_params(dev);
 }
 
 static int blackbird_initialize_codec(struct cx8802_dev *dev)
@@ -851,15 +1320,10 @@ static int bb_buf_setup(struct videobuf_queue *q,
 	struct cx8802_fh *fh = q->priv_data;
 
 	fh->dev->ts_packet_size  = 188 * 4; /* was: 512 */
-	fh->dev->ts_packet_count = 32; /* was: 100 */
+	fh->dev->ts_packet_count = mpegbufs; /* was: 100 */
 
 	*size = fh->dev->ts_packet_size * fh->dev->ts_packet_count;
-	if (0 == *count)
-		*count = mpegbufs;
-	if (*count < 2)
-		*count = 2;
-	if (*count > 32)
-		*count = 32;
+	*count = fh->dev->ts_packet_count;
 	return 0;
 }
 
@@ -868,7 +1332,7 @@ bb_buf_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
 	       enum v4l2_field field)
 {
 	struct cx8802_fh *fh = q->priv_data;
-	return cx8802_buf_prepare(fh->dev, (struct cx88_buffer*)vb);
+	return cx8802_buf_prepare(fh->dev, (struct cx88_buffer*)vb, field);
 }
 
 static void
@@ -920,8 +1384,6 @@ static int mpeg_do_ioctl(struct inode *inode, struct file *file,
 			V4L2_CAP_VIDEO_CAPTURE |
 			V4L2_CAP_READWRITE     |
 			V4L2_CAP_STREAMING     |
-			V4L2_CAP_VBI_CAPTURE   |
-			V4L2_CAP_VIDEO_OVERLAY |
 			0;
 		if (UNSET != core->tuner_type)
 			cap->capabilities |= V4L2_CAP_TUNER;
@@ -941,27 +1403,52 @@ static int mpeg_do_ioctl(struct inode *inode, struct file *file,
 
 		memset(f,0,sizeof(*f));
 		f->index = index;
-		strlcpy(f->description, "MPEG TS", sizeof(f->description));
+		strlcpy(f->description, "MPEG", sizeof(f->description));
 		f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 		f->pixelformat = V4L2_PIX_FMT_MPEG;
 		return 0;
 	}
 	case VIDIOC_G_FMT:
-	case VIDIOC_S_FMT:
-	case VIDIOC_TRY_FMT:
 	{
-		/* FIXME -- quick'n'dirty for exactly one size ... */
 		struct v4l2_format *f = arg;
 
 		memset(f,0,sizeof(*f));
 		f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+		f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
+		f->fmt.pix.bytesperline = 0;
+		f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count; /* 188 * 4 * 1024; */
+		f->fmt.pix.colorspace   = 0;
 		f->fmt.pix.width        = dev->width;
 		f->fmt.pix.height       = dev->height;
+		f->fmt.pix.field        = fh->mpegq.field;
+		dprintk(0,"VIDIOC_G_FMT: w: %d, h: %d, f: %d\n",
+			dev->width, dev->height, fh->mpegq.field );
+		return 0;
+	}
+	case VIDIOC_TRY_FMT:
+	{
+		struct v4l2_format *f = arg;
+
+		f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 		f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
-		f->fmt.pix.field        = V4L2_FIELD_NONE;
 		f->fmt.pix.bytesperline = 0;
-		f->fmt.pix.sizeimage    = 188 * 4 * 1024; /* 1024 * 512 */ /* FIXME: BUFFER_SIZE */;
+		f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count; /* 188 * 4 * 1024; */;
 		f->fmt.pix.colorspace   = 0;
+		dprintk(0,"VIDIOC_TRY_FMT: w: %d, h: %d, f: %d\n",
+			dev->width, dev->height, fh->mpegq.field );
+		return 0;
+	}
+	case VIDIOC_S_FMT:
+	{
+		struct v4l2_format *f = arg;
+
+		f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+		f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
+		f->fmt.pix.bytesperline = 0;
+		f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count; /* 188 * 4 * 1024; */;
+		f->fmt.pix.colorspace   = 0;
+		dprintk(0,"VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
+			f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field );
 		return 0;
 	}
 
@@ -985,6 +1472,22 @@ static int mpeg_do_ioctl(struct inode *inode, struct file *file,
 	case VIDIOC_STREAMOFF:
 		return videobuf_streamoff(&fh->mpegq);
 
+	/* --- mpeg compression -------------------------------------- */
+	case VIDIOC_G_MPEGCOMP:
+	{
+		struct v4l2_mpeg_compression *f = arg;
+
+		memcpy(f,&dev->params,sizeof(*f));
+		return 0;
+	}
+	case VIDIOC_S_MPEGCOMP:
+	{
+		struct v4l2_mpeg_compression *f = arg;
+
+		blackbird_set_params(dev, f);
+		return 0;
+	}
+
 	default:
 		return cx88_do_ioctl( inode, file, 0, dev->core, cmd, arg, cx88_ioctl_hook );
 	}
@@ -1034,16 +1537,17 @@ static int mpeg_open(struct inode *inode, struct file *file)
 	file->private_data = fh;
 	fh->dev      = dev;
 
-	/* FIXME: locking against other video device */
-	cx88_set_scale(dev->core, dev->width, dev->height,
-		       V4L2_FIELD_INTERLACED);
-
 	videobuf_queue_init(&fh->mpegq, &blackbird_qops,
 			    dev->pci, &dev->slock,
 			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
-			    V4L2_FIELD_TOP,
+			    V4L2_FIELD_INTERLACED,
 			    sizeof(struct cx88_buffer),
 			    fh);
+
+	/* FIXME: locking against other video device */
+	cx88_set_scale(dev->core, dev->width, dev->height,
+			fh->mpegq.field);
+
 	return 0;
 }
 
@@ -1173,6 +1677,8 @@ static int __devinit blackbird_probe(struct pci_dev *pci_dev,
 	dev->core = core;
 	dev->width = 720;
 	dev->height = 576;
+	memcpy(&dev->params,&default_mpeg_params,sizeof(default_mpeg_params));
+	memcpy(&dev->dnr_params,&default_dnr_params,sizeof(default_dnr_params));
 
 	err = cx8802_init_common(dev);
 	if (0 != err)
@@ -1257,6 +1763,8 @@ module_exit(blackbird_fini);
 
 EXPORT_SYMBOL(cx88_ioctl_hook);
 EXPORT_SYMBOL(cx88_ioctl_translator);
+EXPORT_SYMBOL(blackbird_set_params);
+EXPORT_SYMBOL(blackbird_set_dnr_params);
 
 /* ----------------------------------------------------------- */
 /*

drivers/media/video/cx88/cx88-mpeg.c

@@ -54,7 +54,7 @@ static int cx8802_start_dma(struct cx8802_dev    *dev,
 {
 	struct cx88_core *core = dev->core;
 
-	dprintk(0, "cx8802_start_dma %d\n", buf->vb.width);
+	dprintk(0, "cx8802_start_dma w: %d, h: %d, f: %d\n", dev->width, dev->height, buf->vb.field);
 
 	/* setup fifo + format */
 	cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH28],
@@ -158,7 +158,8 @@ static int cx8802_restart_queue(struct cx8802_dev    *dev,
 
 /* ------------------------------------------------------------------ */
 
-int cx8802_buf_prepare(struct cx8802_dev *dev, struct cx88_buffer *buf)
+int cx8802_buf_prepare(struct cx8802_dev *dev, struct cx88_buffer *buf,
+			enum v4l2_field field)
 {
 	int size = dev->ts_packet_size * dev->ts_packet_count;
 	int rc;
@@ -171,7 +172,7 @@ int cx8802_buf_prepare(struct cx8802_dev *dev, struct cx88_buffer *buf)
 		buf->vb.width  = dev->ts_packet_size;
 		buf->vb.height = dev->ts_packet_count;
 		buf->vb.size   = size;
-		buf->vb.field  = V4L2_FIELD_TOP;
+		buf->vb.field  = field /*V4L2_FIELD_TOP*/;
 
 		if (0 != (rc = videobuf_iolock(dev->pci,&buf->vb,NULL)))
 			goto fail;

drivers/media/video/cx88/cx88-video.c

@@ -1258,8 +1258,6 @@ int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
 
 	if (video_debug > 1)
 		cx88_print_ioctl(core->name,cmd);
-	printk( KERN_INFO "CORE IOCTL: 0x%x\n", cmd );
-	cx88_print_ioctl(core->name,cmd);
 	dprintk( 1, "CORE IOCTL: 0x%x\n", cmd );
 
 	switch (cmd) {

drivers/media/video/cx88/cx88.h

@@ -371,6 +371,14 @@ struct cx8802_suspend_state {
 	int                        disabled;
 };
 
+/* TODO: move this to struct v4l2_mpeg_compression ? */
+struct blackbird_dnr {
+	u32                       mode;
+	u32                       type;
+	u32                       spatial;
+	u32                       temporal;
+};
+
 struct cx8802_dev {
 	struct cx88_core           *core;
 	spinlock_t                 slock;
@@ -401,6 +409,10 @@ struct cx8802_dev {
 
 	/* for switching modulation types */
 	unsigned char              ts_gen_cntrl;
+
+	/* mpeg params */
+	struct v4l2_mpeg_compression params;
+	struct blackbird_dnr       dnr_params;
 };
 
 /* ----------------------------------------------------------- */
@@ -542,7 +554,8 @@ void cx88_ir_irq(struct cx88_core *core);
 /* ----------------------------------------------------------- */
 /* cx88-mpeg.c                                                 */
 
-int cx8802_buf_prepare(struct cx8802_dev *dev, struct cx88_buffer *buf);
+int cx8802_buf_prepare(struct cx8802_dev *dev, struct cx88_buffer *buf,
+			enum v4l2_field field);
 void cx8802_buf_queue(struct cx8802_dev *dev, struct cx88_buffer *buf);
 void cx8802_cancel_buffers(struct cx8802_dev *dev);
 
@@ -563,6 +576,10 @@ extern int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
 extern int (*cx88_ioctl_hook)(struct inode *inode, struct file *file,
 				unsigned int cmd, void *arg);
 extern unsigned int (*cx88_ioctl_translator)(unsigned int cmd);
+void blackbird_set_params(struct cx8802_dev *dev,
+				struct v4l2_mpeg_compression *params);
+void blackbird_set_dnr_params(struct cx8802_dev *dev,
+				struct blackbird_dnr* dnr_params);
 
 /*
  * Local variables: