Hi Miguel, On 02/11/2015 07:39 PM, Miguel Casas-Sanchez wrote: > Add support for vertical + horizontal subsampled formats to vivid and use it to > generate YU12, YV12, NV12, NV21 as defined in [1,2]. These formats are tightly > packed N planar, because they provide chroma(s) as a separate array, but they > are not mplanar yet, as discussed in the list. > > The modus operandi is to let tpg_fillbuffer() create a YUYV packed format per > pattern line as usual and apply downsampling if needed immediately afterwards, > in a new function called tpg_apply_downsampling(). This one will unpack as > needed, and average the chroma samples (note that luma samples are never > downsampled). (Some provisions for horizontal downsampling are made, so it can > be followed up with e.g. YUV410 etc formats, please understand in this context). > Writing the text information on top of the produced pattern also needs a bit of > a retouch. > > [1] http://linuxtv.org/downloads/v4l-dvb-apis/re30.html > [2] http://linuxtv.org/downloads/v4l-dvb-apis/re24.html > > Signed-off-by: Miguel Casas-Sanchez <mcasas@xxxxxxxxxxxx> I'm afraid there are a number of issues with this patch that prevent it from being merged. First of all, your mailer wraps around long lines, making it impossible to apply this patch. Instead, I've used your earlier post that attached the patch. I'm assuming the two are identical. Secondly, I noticed various spurious whitespace changes that made the patch longer than necessary. Thirdly, you didn't check the patch with checkpatch.pl. Also note that the ENUM_FMT descriptions are too long: the string is cut off. Easy to see with qv4l2. Much more serious is that you break the pattern movements, the border, the square and the vertical flip support for these new pixel formats. That really must remain functional. The 'Insert SAV/EAV Code' controls are also not working, but in all fairness, I don't think those make sense for these subsampled formats. Cropping and scaling is also broken. I noticed that when printing the text you only fill in the luma and not the chroma, effectively making that transparent. Which may not be a bad idea. However, note that the 'Noise' test pattern is broken with the new formats. Conclusion: there is a lot more work to be done here... Regards, Hans > --- > drivers/media/platform/vivid/vivid-kthread-cap.c | 6 +- > drivers/media/platform/vivid/vivid-tpg.c | 232 +++++++++++++++++++---- > drivers/media/platform/vivid/vivid-tpg.h | 15 +- > drivers/media/platform/vivid/vivid-vid-common.c | 28 +++ > 4 files changed, 238 insertions(+), 43 deletions(-) > > diff --git a/drivers/media/platform/vivid/vivid-kthread-cap.c > b/drivers/media/platform/vivid/vivid-kthread-cap.c > index 39a67cf..93c6ca3 100644 > --- a/drivers/media/platform/vivid/vivid-kthread-cap.c > +++ b/drivers/media/platform/vivid/vivid-kthread-cap.c > @@ -669,8 +669,7 @@ static void vivid_thread_vid_cap_tick(struct > vivid_dev *dev, int dropped_bufs) > if (vid_cap_buf) { > /* Fill buffer */ > vivid_fillbuff(dev, vid_cap_buf); > - dprintk(dev, 1, "filled buffer %d\n", > - vid_cap_buf->vb.v4l2_buf.index); > + dprintk(dev, 1, "filled buffer %d\n", > vid_cap_buf->vb.v4l2_buf.index); > > /* Handle overlay */ > if (dev->overlay_cap_owner && dev->fb_cap.base && > @@ -679,8 +678,7 @@ static void vivid_thread_vid_cap_tick(struct > vivid_dev *dev, int dropped_bufs) > > vb2_buffer_done(&vid_cap_buf->vb, dev->dqbuf_error ? > VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE); > - dprintk(dev, 2, "vid_cap buffer %d done\n", > - vid_cap_buf->vb.v4l2_buf.index); > + dprintk(dev, 2, "vid_cap buffer %d done\n", > vid_cap_buf->vb.v4l2_buf.index); > } > > if (vbi_cap_buf) { > diff --git a/drivers/media/platform/vivid/vivid-tpg.c > b/drivers/media/platform/vivid/vivid-tpg.c > index 34493f4..d72e19a 100644 > --- a/drivers/media/platform/vivid/vivid-tpg.c > +++ b/drivers/media/platform/vivid/vivid-tpg.c > @@ -193,6 +193,10 @@ bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc) > case V4L2_PIX_FMT_UYVY: > case V4L2_PIX_FMT_YVYU: > case V4L2_PIX_FMT_VYUY: > + case V4L2_PIX_FMT_NV12: > + case V4L2_PIX_FMT_NV21: > + case V4L2_PIX_FMT_YUV420: > + case V4L2_PIX_FMT_YVU420: > tpg->is_yuv = true; > break; > default: > @@ -224,12 +228,32 @@ bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc) > case V4L2_PIX_FMT_ABGR32: > tpg->twopixelsize[0] = 2 * 4; > break; > + case V4L2_PIX_FMT_NV12: > + case V4L2_PIX_FMT_NV21: > + case V4L2_PIX_FMT_YUV420: > + case V4L2_PIX_FMT_YVU420: > + tpg->twopixelsize[0] = 3; > + break; > case V4L2_PIX_FMT_NV16M: > case V4L2_PIX_FMT_NV61M: > tpg->twopixelsize[0] = 2; > tpg->twopixelsize[1] = 2; > break; > } > + > + switch (fourcc) { > + case V4L2_PIX_FMT_NV12: > + case V4L2_PIX_FMT_NV21: > + case V4L2_PIX_FMT_YUV420: > + case V4L2_PIX_FMT_YVU420: > + tpg->vertical_downsampling = 2; > + tpg->horizontal_downsampling = 2; > + break; > + default: > + tpg->vertical_downsampling = 0; > + tpg->horizontal_downsampling = 0; > + } > + > return true; > } > > @@ -271,6 +295,12 @@ void tpg_reset_source(struct tpg_data *tpg, > unsigned width, unsigned height, > tpg->recalc_square_border = true; > } > > +/* Vertically downsampled pixel formats use YUYV as intermediate. */ > +static unsigned tpg_get_packed_twopixsize(struct tpg_data *tpg, unsigned p) > +{ > + return tpg->vertical_downsampling ? 4 : tpg->twopixelsize[p]; > +} > + > static enum tpg_color tpg_get_textbg_color(struct tpg_data *tpg) > { > switch (tpg->pattern) { > @@ -673,7 +703,15 @@ static void gen_twopix(struct tpg_data *tpg, > buf[0][offset] = r_y; > buf[1][offset] = odd ? g_u : b_v; > break; > - > + /* > + * For these cases we compose a YUYV macropixel. They will be > verticallly > + * downsampled later on. > + */ > + case V4L2_PIX_FMT_NV12: > + case V4L2_PIX_FMT_NV21: > + case V4L2_PIX_FMT_YUV420: > + case V4L2_PIX_FMT_YVU420: > + offset = odd * tpg_get_packed_twopixsize(tpg, 0) / 2; > case V4L2_PIX_FMT_YUYV: > buf[0][offset] = r_y; > buf[0][offset + 1] = odd ? b_v : g_u; > @@ -1000,9 +1038,8 @@ static void tpg_precalculate_line(struct tpg_data *tpg) > gen_twopix(tpg, pix, tpg->hflip ? color2 : color1, 0); > gen_twopix(tpg, pix, tpg->hflip ? color1 : color2, 1); > for (p = 0; p < tpg->planes; p++) { > - unsigned twopixsize = tpg->twopixelsize[p]; > + const unsigned twopixsize = > tpg_get_packed_twopixsize(tpg, p); > u8 *pos = tpg->lines[pat][p] + x * > twopixsize / 2; > - > memcpy(pos, pix[p], twopixsize); > } > } > @@ -1013,7 +1050,7 @@ static void tpg_precalculate_line(struct tpg_data *tpg) > gen_twopix(tpg, pix, contrast, 0); > gen_twopix(tpg, pix, contrast, 1); > for (p = 0; p < tpg->planes; p++) { > - unsigned twopixsize = tpg->twopixelsize[p]; > + const unsigned twopixsize = > tpg_get_packed_twopixsize(tpg, p); > u8 *pos = tpg->contrast_line[p] + x * twopixsize / 2; > > memcpy(pos, pix[p], twopixsize); > @@ -1025,9 +1062,8 @@ static void tpg_precalculate_line(struct tpg_data *tpg) > gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 0); > gen_twopix(tpg, pix, TPG_COLOR_100_BLACK, 1); > for (p = 0; p < tpg->planes; p++) { > - unsigned twopixsize = tpg->twopixelsize[p]; > + const unsigned twopixsize = > tpg_get_packed_twopixsize(tpg, p); > u8 *pos = tpg->black_line[p] + x * twopixsize / 2; > - > memcpy(pos, pix[p], twopixsize); > } > } > @@ -1037,7 +1073,7 @@ static void tpg_precalculate_line(struct tpg_data *tpg) > gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 0); > gen_twopix(tpg, pix, TPG_COLOR_RANDOM, 1); > for (p = 0; p < tpg->planes; p++) { > - unsigned twopixsize = tpg->twopixelsize[p]; > + const unsigned twopixsize = > tpg_get_packed_twopixsize(tpg, p); > u8 *pos = tpg->random_line[p] + x * twopixsize / 2; > > memcpy(pos, pix[p], twopixsize); > @@ -1083,8 +1119,8 @@ void tpg_gen_text(struct tpg_data *tpg, u8 > *basep[TPG_MAX_PLANES][2], > div = 2; > > for (p = 0; p < tpg->planes; p++) { > - /* Print stream time */ > -#define PRINTSTR(PIXTYPE) do { \ > + /* Print text */ > +#define PRINTSTR(PIXTYPE, dst_ptr, stride) do { \ > PIXTYPE fg; \ > PIXTYPE bg; \ > memcpy(&fg, tpg->textfg[p], sizeof(PIXTYPE)); \ > @@ -1092,32 +1128,31 @@ void tpg_gen_text(struct tpg_data *tpg, u8 > *basep[TPG_MAX_PLANES][2], > \ > for (line = first; line < 16; line += step) { \ > int l = tpg->vflip ? 15 - line : line; \ > - PIXTYPE *pos = (PIXTYPE *)(basep[p][line & 1] + \ > - ((y * step + l) / div) * tpg->bytesperline[p] + \ > + PIXTYPE *pos = (PIXTYPE *)((dst_ptr)[line & 1] + \ > + ((y * step + l) / div) * stride + \ > x * sizeof(PIXTYPE)); \ > - unsigned s; \ > \ > + unsigned s; \ > for (s = 0; s < len; s++) { \ > u8 chr = font8x16[text[s] * 16 + line]; \ > - \ > if (tpg->hflip) { \ > - pos[7] = (chr & (0x01 << 7) ? fg : bg); \ > - pos[6] = (chr & (0x01 << 6) ? fg : bg); \ > - pos[5] = (chr & (0x01 << 5) ? fg : bg); \ > - pos[4] = (chr & (0x01 << 4) ? fg : bg); \ > - pos[3] = (chr & (0x01 << 3) ? fg : bg); \ > - pos[2] = (chr & (0x01 << 2) ? fg : bg); \ > - pos[1] = (chr & (0x01 << 1) ? fg : bg); \ > - pos[0] = (chr & (0x01 << 0) ? fg : bg); \ > + pos[7] = (chr & (0x01 << 7) ? fg : bg); \ > + pos[6] = (chr & (0x01 << 6) ? fg : bg); \ > + pos[5] = (chr & (0x01 << 5) ? fg : bg); \ > + pos[4] = (chr & (0x01 << 4) ? fg : bg); \ > + pos[3] = (chr & (0x01 << 3) ? fg : bg); \ > + pos[2] = (chr & (0x01 << 2) ? fg : bg); \ > + pos[1] = (chr & (0x01 << 1) ? fg : bg); \ > + pos[0] = (chr & (0x01 << 0) ? fg : bg); \ > } else { \ > - pos[0] = (chr & (0x01 << 7) ? fg : bg); \ > - pos[1] = (chr & (0x01 << 6) ? fg : bg); \ > - pos[2] = (chr & (0x01 << 5) ? fg : bg); \ > - pos[3] = (chr & (0x01 << 4) ? fg : bg); \ > - pos[4] = (chr & (0x01 << 3) ? fg : bg); \ > - pos[5] = (chr & (0x01 << 2) ? fg : bg); \ > - pos[6] = (chr & (0x01 << 1) ? fg : bg); \ > - pos[7] = (chr & (0x01 << 0) ? fg : bg); \ > + pos[0] = (chr & (0x01 << 7) ? fg : bg); \ > + pos[1] = (chr & (0x01 << 6) ? fg : bg); \ > + pos[2] = (chr & (0x01 << 5) ? fg : bg); \ > + pos[3] = (chr & (0x01 << 4) ? fg : bg); \ > + pos[4] = (chr & (0x01 << 3) ? fg : bg); \ > + pos[5] = (chr & (0x01 << 2) ? fg : bg); \ > + pos[6] = (chr & (0x01 << 1) ? fg : bg); \ > + pos[7] = (chr & (0x01 << 0) ? fg : bg); \ > } \ > \ > pos += tpg->hflip ? -8 : 8; \ > @@ -1125,15 +1160,25 @@ void tpg_gen_text(struct tpg_data *tpg, u8 > *basep[TPG_MAX_PLANES][2], > } \ > } while (0) > > - switch (tpg->twopixelsize[p]) { > - case 2: > - PRINTSTR(u8); break; > - case 4: > - PRINTSTR(u16); break; > - case 6: > - PRINTSTR(x24); break; > - case 8: > - PRINTSTR(u32); break; > + if (!tpg->vertical_downsampling) { > + switch (tpg->twopixelsize[p]) { > + case 2: > + PRINTSTR(u8, basep[p], > tpg->bytesperline[p]); break; > + case 4: > + PRINTSTR(u16, basep[p], > tpg->bytesperline[p]); break; > + case 6: > + PRINTSTR(x24, basep[p], > tpg->bytesperline[p]); break; > + case 8: > + PRINTSTR(u32, basep[p], > tpg->bytesperline[p]); break; > + } > + } else { > + /* tpg->twopixelsize[p] is 3 for the defined > formats so far. */ > + if (tpg->twopixelsize[p] != 3) { > + printk(KERN_WARNING "Unsupported twopixelsize"); > + return; > + } > + PRINTSTR(u8, basep[p], tpg->compose.width); > + /* TODO(mcasas): Do the same for Chroma > planes, not urgently needed. */ > } > } > } > @@ -1551,4 +1596,115 @@ void tpg_fillbuffer(struct tpg_data *tpg, > v4l2_std_id std, unsigned p, u8 *vbuf) > (hact ^ vact ^ f); > } > } > + > + tpg_apply_downsampling(tpg, std, p, vbuf); > +} > + > +/* > + * Apply downsampling(s). Assumes that pattern lines have been generated in > + * packed YUYV and written in tpg->lines: we unpack them in the appropriate > + * plane locations, which depend on the concrete format and its planarity > + * and chroma packaging. > + */ > +void tpg_apply_downsampling(struct tpg_data *tpg, v4l2_std_id std, unsigned p, > + u8 *vbuf) > +{ > + u8 *y_ptr = vbuf; > + u8 *chromas_start = y_ptr + (tpg->compose.height * tpg->compose.width); > + u8 *u_ptr; > + u8 *v_ptr; > + u8 u_ptr_step = 1; > + u8 v_ptr_step = 1; > + int y; > + > + if (tpg->vertical_downsampling == 0) > + return; > + if (tpg->vertical_downsampling > 2) { > + printk(KERN_WARNING "Vertical downsampling by > 2 not > implemented\n"); > + return; > + } > + if (tpg->horizontal_downsampling > 2) { > + printk(KERN_WARNING "Horizontal downsampling by > 2 > not implemented\n"); > + return; > + } > + if (tpg->planes > 1) { > + printk(KERN_WARNING "Mplane vertically downsampling > not implemented\n"); > + return; > + } > + > + switch (tpg->fourcc) { > + case V4L2_PIX_FMT_YUV420: > + u_ptr = chromas_start; > + v_ptr = chromas_start + > + (tpg->compose.height * tpg->compose.width) / > + (2 * tpg->horizontal_downsampling); > + break; > + case V4L2_PIX_FMT_YVU420: > + v_ptr = chromas_start; > + u_ptr = chromas_start + > + (tpg->compose.height * tpg->compose.width) / > + (2 * tpg->horizontal_downsampling); > + break; > + case V4L2_PIX_FMT_NV12: /* N{21,21} are special: interleaved > chromas. */ > + u_ptr = chromas_start; > + v_ptr = u_ptr + 1; > + u_ptr_step = v_ptr_step = 2; > + break; > + case V4L2_PIX_FMT_NV21: > + v_ptr = chromas_start; > + u_ptr = v_ptr + 1; > + u_ptr_step = v_ptr_step = 2; > + break; > + default: > + printk(KERN_ERR "Unknown vertically downsampled format\n"); > + return; > + } > + > + /* > + * Per line: fetch the pattern line to use in packed YUYV, > then unpack in > + * the dst buffers. Vertical downsampling can only be 2 or 4 > here: average > + * as-many-rows of Chroma components. Since we use YUYV as > starting point, > + * horizontal downsampling of 2 is a natural match; 4 would need hoops. > + */ > + for (y = 0; y < tpg->compose.height; y += 2) { > + u8 *src_ptr; > + unsigned buf_line; > + unsigned downsampling_index = 0; > + > + for (; downsampling_index < tpg->vertical_downsampling; > + ++downsampling_index) { > + int x; > + > + /* Fetch the pattern line to use in packed YUYV. */ > + buf_line = tpg_calc_buffer_line(tpg, y + > downsampling_index, > + tpg->field); > + src_ptr = tpg->lines[tpg_get_pat_line(tpg, > buf_line)][0]; > + if ((downsampling_index % > tpg->vertical_downsampling) == 0) { > + /* Unpack yuyv macropixel. _Set_ the > Chroma planes. */ > + for (x = 0; x < 2 * > tpg->compose.width; x += 4) { > + *y_ptr++ = *src_ptr++; > + *u_ptr = *src_ptr++ / > tpg->vertical_downsampling; > + u_ptr += u_ptr_step; > + *y_ptr++ = *src_ptr++; > + *v_ptr = *src_ptr++ / > tpg->vertical_downsampling; > + v_ptr += v_ptr_step; > + } > + } else { > + /* Rewind U, V pointers. */ > + u_ptr -= (u_ptr_step * tpg->compose.width / > + tpg->horizontal_downsampling); > + v_ptr -= (v_ptr_step * tpg->compose.width / > + tpg->horizontal_downsampling); > + /* Unpack yuyv macropixel. > _Accumulate_ the Chroma planes. */ > + for (x = 0; x < 2 * > tpg->compose.width; x += 4) { > + *y_ptr++ = *src_ptr++; > + *u_ptr += *src_ptr++ / > tpg->vertical_downsampling; > + u_ptr += u_ptr_step; > + *y_ptr++ = *src_ptr++; > + *v_ptr += *src_ptr++ / > tpg->vertical_downsampling; > + v_ptr += v_ptr_step; > + } > + } > + } > + } > } > diff --git a/drivers/media/platform/vivid/vivid-tpg.h > b/drivers/media/platform/vivid/vivid-tpg.h > index bd8b1c7..ac374f1 100644 > --- a/drivers/media/platform/vivid/vivid-tpg.h > +++ b/drivers/media/platform/vivid/vivid-tpg.h > @@ -141,6 +141,14 @@ struct tpg_data { > /* size in bytes for two pixels in each plane */ > unsigned twopixelsize[TPG_MAX_PLANES]; > unsigned bytesperline[TPG_MAX_PLANES]; > + /* > + * Vertical and horizontal downsample factors. Only applies to > YUV formats, > + * concretely Chroma components (not the Luma), and implies > that the format > + * is planar (2 or 3 planes). Only even numbers are allowed. > Typical values > + * include 0 for no downsampling and 2 (like in 4:2:0 formats, > e.g. YUV420). > + */ > + unsigned vertical_downsampling; > + unsigned horizontal_downsampling; > > /* Configuration */ > enum tpg_pattern pattern; > @@ -165,7 +173,10 @@ struct tpg_data { > bool recalc_lines; > bool recalc_square_border; > > - /* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */ > + /* > + * Used to store TPG_MAX_PAT_LINES lines, each with up to > TPG_MAX_PLANES > + * planes > + */ > unsigned max_line_width; > u8 > *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES]; > u8 *random_line[TPG_MAX_PLANES]; > @@ -185,6 +196,8 @@ void tpg_gen_text(struct tpg_data *tpg, > void tpg_calc_text_basep(struct tpg_data *tpg, > u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf); > void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std, unsigned > p, u8 *vbuf); > +void tpg_apply_downsampling(struct tpg_data *tpg, v4l2_std_id std, unsigned p, > + u8 *vbuf); > bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc); > void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop, > const struct v4l2_rect *compose); > diff --git a/drivers/media/platform/vivid/vivid-vid-common.c > b/drivers/media/platform/vivid/vivid-vid-common.c > index 6bef1e6..99e0d22 100644 > --- a/drivers/media/platform/vivid/vivid-vid-common.c > +++ b/drivers/media/platform/vivid/vivid-vid-common.c > @@ -73,6 +73,34 @@ struct vivid_fmt vivid_formats[] = { > .planes = 1, > }, > { > + .name = "YUV 4:2:0, planar, 1 Chroma plane", > + .fourcc = V4L2_PIX_FMT_NV12, > + .depth = 12, > + .is_yuv = true, > + .planes = 1, > + }, > + { > + .name = "YVU 4:2:0, planar, 1 Chroma plane", > + .fourcc = V4L2_PIX_FMT_NV21, > + .depth = 12, > + .is_yuv = true, > + .planes = 1, > + }, > + { > + .name = "YUV 4:2:0, planar, 2 Chroma planes", > + .fourcc = V4L2_PIX_FMT_YUV420, > + .depth = 12, > + .is_yuv = true, > + .planes = 1, > + }, > + { > + .name = "YVU 4:2:0, planar, 2 Chroma planes", > + .fourcc = V4L2_PIX_FMT_YVU420, > + .depth = 12, > + .is_yuv = true, > + .planes = 1, > + }, > + { > .name = "RGB565 (LE)", > .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */ > .depth = 16, > > -- > 2.2.0.rc0.207.ga3a616c > -- > To unsubscribe from this list: send the line "unsubscribe linux-media" in > the body of a message to majordomo@xxxxxxxxxxxxxxx > More majordomo info at http://vger.kernel.org/majordomo-info.html > -- To unsubscribe from this list: send the line "unsubscribe linux-media" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
