Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4ab9b256 authored by Andy Walls's avatar Andy Walls Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (11092): cx18: Optimize processing of VBI buffers from the capture unit 



Removed some unnecessary memcpy()'s by reworking the compress_*_vbi_buf()
functions.

Signed-off-by: default avatarAndy Walls <awalls@radix.net>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 6e1a6372

drivers/media/video/cx18/cx18-vbi.c

+49 −54
Original line number Diff line number Diff line
@@ -105,54 +105,72 @@ static void copy_vbi_data(struct cx18 *cx, int lines, u32 pts_stamp) 


/* Compress raw VBI format, removes leading SAV codes and surplus space

   after the frame.  Returns new compressed size. */

static u32 compress_raw_buf(struct cx18 *cx, u8 *buf, u32 size)

static u32 compress_raw_buf(struct cx18 *cx, u8 *buf, u32 size, u32 hdr_size)

{

	u32 line_size = vbi_active_samples;

	u32 lines = cx->vbi.count * 2;

	u8 sav1 = raw_vbi_sav_rp[0];

	u8 sav2 = raw_vbi_sav_rp[1];

	u8 *q = buf;

	u8 *p;

	int i;



	/* Skip the header */

	buf += hdr_size;



	for (i = 0; i < lines; i++) {

		p = buf + i * line_size;



		/* Look for SAV code */

		if (p[0] != 0xff || p[1] || p[2] ||

		    (p[3] != sav1 && p[3] != sav2))

		    (p[3] != raw_vbi_sav_rp[0] &&

		     p[3] != raw_vbi_sav_rp[1]))

			break;

		if (i == lines - 1) {

			/* last line is hdr_size bytes short - extrapolate it */

			memcpy(q, p + 4, line_size - 4 - hdr_size);

			q += line_size - 4 - hdr_size;

			p += line_size - hdr_size - 1;

			memset(q, (int) *p, hdr_size);

		} else {

			memcpy(q, p + 4, line_size - 4);

			q += line_size - 4;

		}

	}

	return lines * (line_size - 4);

}





/* Compressed VBI format, all found sliced blocks put next to one another

   Returns new compressed size */

static u32 compress_sliced_buf(struct cx18 *cx, u32 line, u8 *buf,

			       u32 size, u8 eav)

static u32 compress_sliced_buf(struct cx18 *cx, u8 *buf, u32 size,

			       const u32 hdr_size)

{

	struct v4l2_decode_vbi_line vbi;

	int i;

	u32 line = 0;

	u32 line_size = cx->is_60hz ? vbi_hblank_samples_60Hz

				    : vbi_hblank_samples_50Hz;



	/* find the first valid line */

	for (i = 0; i < size; i++, buf++) {

		if (buf[0] == 0xff && !buf[1] && !buf[2] && buf[3] == eav)

	for (i = hdr_size, buf += hdr_size; i < size; i++, buf++) {

		if (buf[0] == 0xff && !buf[1] && !buf[2] &&

		    (buf[3] == sliced_vbi_eav_rp[0] ||

		     buf[3] == sliced_vbi_eav_rp[1]))

			break;

	}



	size -= i;

	/*

	 * The last line is short by hdr_size bytes, but for the remaining

	 * checks against size, we pretend that it is not, by counting the

	 * header bytes we knowingly skipped

	 */

	size -= (i - hdr_size);

	if (size < line_size)

		return line;



	for (i = 0; i < size / line_size; i++) {

		u8 *p = buf + i * line_size;



		/* Look for EAV code  */

		if (p[0] != 0xff || p[1] || p[2] || p[3] != eav)

		if (p[0] != 0xff || p[1] || p[2] ||

		    (p[3] != sliced_vbi_eav_rp[0] &&

		     p[3] != sliced_vbi_eav_rp[1]))

			continue;

		vbi.p = p + 4;

		v4l2_subdev_call(cx->sd_av, video, decode_vbi_line, &vbi);
@@ -170,8 +188,17 @@ static u32 compress_sliced_buf(struct cx18 *cx, u32 line, u8 *buf, 
void cx18_process_vbi_data(struct cx18 *cx, struct cx18_buffer *buf,

			   int streamtype)

{

	/*

	 * The CX23418 provides a 12 byte header in its raw VBI buffers to us:

	 * 0x3fffffff [4 bytes of something] [4 byte presentation time stamp]

	 */

	struct vbi_data_hdr {

		__be32 magic;

		__be32 unknown;

		__be32 pts;

	} *hdr = (struct vbi_data_hdr *) buf->buf;



	u8 *p = (u8 *) buf->buf;

	__be32 *q = (__be32 *) buf->buf;

	u32 size = buf->bytesused;

	u32 pts;

	int lines;
@@ -182,32 +209,15 @@ void cx18_process_vbi_data(struct cx18 *cx, struct cx18_buffer *buf, 
	/*

	 * The CX23418 sends us data that is 32 bit little-endian swapped,

	 * but we want the raw VBI bytes in the order they were in the raster

	 * line.  This has a side effect of making the 12 byte header big endian

	 * line.  This has a side effect of making the header big endian

	 */

	cx18_buf_swap(buf);



	/*

	 * The CX23418 provides a 12 byte header in it's raw VBI buffers to us:

	 * 0x3fffffff [4 bytes of something] [4 byte presentation time stamp?]

	 */



	/* Raw VBI data */

	if (cx18_raw_vbi(cx)) {

		u8 type;



		/*

		 * We've set up to get a frame's worth of VBI data at a time.

		 * Skip 12 bytes of header prefixing the first field.

		 */

		size -= 12;

		memcpy(p, &buf->buf[12], size);

		type = p[3];



		/* Extrapolate the last 12 bytes of the frame's last line */

		memset(&p[size], (int) p[size - 1], 12);

		size += 12;



		size = buf->bytesused = compress_raw_buf(cx, p, size);

		size = buf->bytesused =

		     compress_raw_buf(cx, p, size, sizeof(struct vbi_data_hdr));



		/*

		 * Hack needed for compatibility with old VBI software.
@@ -221,26 +231,11 @@ void cx18_process_vbi_data(struct cx18 *cx, struct cx18_buffer *buf, 


	/* Sliced VBI data with data insertion */



	pts = (be32_to_cpu(q[0]) == 0x3fffffff) ? be32_to_cpu(q[2]) : 0;

	pts = (be32_to_cpu(hdr->magic) == 0x3fffffff) ? be32_to_cpu(hdr->pts)

						      : 0;



	/*

	 * For calls to compress_sliced_buf(), ensure there are an integral

	 * number of lines by shifting the real data up over the 12 bytes header

	 * that got stuffed in.

	 * FIXME - there's a smarter way to do this with pointers, but for some

	 * reason I can't get it to work correctly right now.

	 */

	memcpy(p, &buf->buf[12], size-12);

	lines = compress_sliced_buf(cx, p, size, sizeof(struct vbi_data_hdr));



	/* first field */

	lines = compress_sliced_buf(cx, 0, p, size / 2, sliced_vbi_eav_rp[0]);

	/*

	 * second field

	 * In case the second half does not always begin at the exact address,

	 * start a bit earlier (hence 32).

	 */

	lines = compress_sliced_buf(cx, lines, p + size / 2 - 32,

			size / 2 + 32, sliced_vbi_eav_rp[1]);

	/* always return at least one empty line */

	if (lines == 0) {

		cx->vbi.sliced_data[0].id = 0;