[Mplayer-cvslog] CVS: main/libvo vo_yuv4mpeg.c,1.9,1.10
Arpi of Ize
arpi at mplayerhq.hu
Fri Jul 5 00:19:55 CEST 2002
Update of /cvsroot/mplayer/main/libvo
In directory mail:/var/tmp.root/cvs-serv28192/libvo
Modified Files:
vo_yuv4mpeg.c
Log Message:
subrip sometimes uses pipe as newline separator - patch by MOLNAR Andor <dolphy at inf.elte.hu>
Index: vo_yuv4mpeg.c
===================================================================
RCS file: /cvsroot/mplayer/main/libvo/vo_yuv4mpeg.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- vo_yuv4mpeg.c 27 May 2002 18:03:47 -0000 1.9
+++ vo_yuv4mpeg.c 4 Jul 2002 22:19:52 -0000 1.10
@@ -8,6 +8,12 @@
*
* This is undoubtedly incomplete, inaccurate, or just plain wrong. :-)
*
+ * 2002/06/19 Klaus Stengel <Klaus.Stengel at asamnet.de>
+ * - added support for interlaced output
+ * Activate by using '-vo yuv4mpeg:interlaced'
+ * or '-vo yuv4mpeg:interlaced_bf' if your source has
+ * bottom fields first
+ * - added some additional checks to catch problems
*
* 2002/04/17 Juergen Hammelmann <juergen.hammelmann at gmx.de>
* - added support for output of subtitles
@@ -49,35 +55,85 @@
static uint8_t *image_u = NULL;
static uint8_t *image_v = NULL;
+static uint8_t *rgb_buffer = NULL;
+static uint8_t *rgb_line_buffer = NULL;
+
static int using_format = 0;
static FILE *yuv_out;
-int write_bytes;
+static int write_bytes;
+
+#define Y4M_ILACE_NONE 'p' /* non-interlaced, progressive frame */
+#define Y4M_ILACE_TOP_FIRST 't' /* interlaced, top-field first */
+#define Y4M_ILACE_BOTTOM_FIRST 'b' /* interlaced, bottom-field first */
+
+/* Set progressive mode as default */
+static int config_interlace = Y4M_ILACE_NONE;
+#define Y4M_IS_INTERLACED (config_interlace != Y4M_ILACE_NONE)
static uint32_t config(uint32_t width, uint32_t height, uint32_t d_width,
uint32_t d_height, uint32_t fullscreen, char *title,
uint32_t format, const vo_tune_info_t *tuneinfo)
{
- image_height = height;
- image_width = width;
- write_bytes = image_width * image_height * 3 / 2;
+ image_height = height;
+ image_width = width;
using_format = format;
- image = malloc(write_bytes);
+
+ if (Y4M_IS_INTERLACED)
+ {
+ if (height % 4)
+ {
+ perror("yuv4mpeg: Interlaced mode requires image height to be divisable by 4");
+ return -1;
+ }
+
+ rgb_line_buffer = malloc(image_width * 3);
+ if (!rgb_line_buffer)
+ {
+ perror("yuv4mpeg: Unable to allocate line buffer for interlaced mode");
+ return -1;
+ }
+
+ if (using_format == IMGFMT_YV12)
+ printf("yuv4mpeg: WARNING: Input not RGB; Can't seperate chrominance by fields!\n");
+ }
+
+ if (width % 2)
+ {
+ perror("yuv4mpeg: Image width must be divisable by 2");
+ return -1;
+ }
+
+ if(using_format != IMGFMT_YV12)
+ {
+ rgb_buffer = malloc(image_width * image_height * 3);
+ if (!rgb_buffer)
+ {
+ perror("yuv4mpeg: Not enough memory to allocate RGB framebuffer");
+ return -1;
+ }
+ }
+
+ write_bytes = image_width * image_height * 3 / 2;
+ image = malloc(write_bytes);
yuv_out = fopen("stream.yuv", "wb");
- if (!yuv_out || image == NULL)
+ if (!yuv_out || image == 0)
{
- perror("Can't get memory or file handle to stream.yuv");
+ perror("yuv4mpeg: Can't get memory or file handle to write stream.yuv");
return -1;
}
image_y = image;
image_u = image_y + image_width * image_height;
- image_v = image_u + (image_width * image_height) / 4;
+ image_v = image_u + image_width * image_height / 4;
// This isn't right.
// But it should work as long as the file isn't interlaced
// or otherwise unusual (the "Ip A0:0" part).
- fprintf(yuv_out, "YUV4MPEG2 W%d H%d F%ld:%ld Ip A0:0\n",
- image_width, image_height, (long)(vo_fps * 1000000.0), 1000000);
+
+ /* At least the interlacing is ok now */
+ fprintf(yuv_out, "YUV4MPEG2 W%d H%d F%ld:%ld I%c A0:0\n",
+ image_width, image_height, (long)(vo_fps * 1000000.0),
+ (long)1000000, config_interlace);
fflush(yuv_out);
return 0;
@@ -88,12 +144,43 @@
return &vo_info;
}
+/* Only use when h divisable by 2! */
+static void swap_fields(uint8_t *ptr, const int h, const int stride)
+{
+ int i;
+
+ for (i=0; i<h; i +=2)
+ {
+ memcpy(rgb_line_buffer , ptr + stride * i , stride);
+ memcpy(ptr + stride * i , ptr + stride * (i+1), stride);
+ memcpy(ptr + stride * (i+1), rgb_line_buffer , stride);
+ }
+}
+
static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
unsigned char *srca, int stride) {
- if(using_format == IMGFMT_YV12)
+ switch (using_format)
{
- vo_draw_alpha_yv12(w, h, src, srca, stride,
- image+(y0*image_width+x0), image_width);
+ case IMGFMT_YV12:
+ vo_draw_alpha_yv12(w, h, src, srca, stride,
+ image + y0 * image_width + x0, image_width);
+ break;
+
+ case IMGFMT_BGR|24:
+ case IMGFMT_RGB|24:
+ if (config_interlace != Y4M_ILACE_BOTTOM_FIRST)
+ vo_draw_alpha_rgb24(w, h, src, srca, stride,
+ rgb_buffer + (y0 * image_width + x0) * 3, image_width * 3);
+ else
+ {
+ swap_fields (rgb_buffer, image_height, image_width * 3);
+
+ vo_draw_alpha_rgb24(w, h, src, srca, stride,
+ rgb_buffer + (y0 * image_width + x0) * 3, image_width * 3);
+
+ swap_fields (rgb_buffer, image_height, image_width * 3);
+ }
+ break;
}
}
@@ -102,22 +189,117 @@
vo_draw_text(image_width, image_height, draw_alpha);
}
+static void deinterleave_fields(uint8_t *ptr, const int stride,
+ const int img_height)
+{
+ unsigned int i, j, k_start = 1, modv = img_height - 1;
+ unsigned char *line_state = malloc(modv);
+
+ for (i=0; i<modv; i++)
+ line_state[i] = 0;
+
+ line_state[0] = 1;
+
+ while(k_start < modv)
+ {
+ i = j = k_start;
+ memcpy(rgb_line_buffer, ptr + stride * i, stride);
+
+ while (!line_state[j])
+ {
+ line_state[j] = 1;
+ i = j;
+ j = j * 2 % modv;
+ memcpy(ptr + stride * i, ptr + stride * j, stride);
+ }
+ memcpy(ptr + stride * i, rgb_line_buffer, stride);
+
+ while(k_start < modv && line_state[k_start])
+ k_start++;
+ }
+ free(line_state);
+}
+
+static void vo_y4m_write(const void *ptr, const size_t num_bytes)
+{
+ if (fwrite(ptr, 1, num_bytes, yuv_out) != num_bytes)
+ perror("yuv4mpeg: Error writing image to output!");
+}
+
static void flip_page (void)
{
+ uint8_t *upper_y, *upper_u, *upper_v, *rgb_buffer_lower;
+ int rgb_stride, uv_stride, field_height;
+ unsigned int i, low_ofs;
+
fprintf(yuv_out, "FRAME\n");
- if(fwrite(image, 1, write_bytes, yuv_out) != write_bytes)
- perror("Error writing image to output!");
- return;
+
+ if (using_format != IMGFMT_YV12)
+ {
+ rgb_stride = image_width * 3;
+ uv_stride = image_width / 2;
+
+ if (Y4M_IS_INTERLACED)
+ {
+ field_height = image_height / 2;
+
+ upper_y = image;
+ upper_u = upper_y + image_width * field_height;
+ upper_v = upper_u + image_width * field_height / 4;
+ low_ofs = image_width * field_height * 3 / 2;
+ rgb_buffer_lower = rgb_buffer + rgb_stride * field_height;
+
+ deinterleave_fields(rgb_buffer, rgb_stride, image_height);
+
+ rgb24toyv12(rgb_buffer, upper_y, upper_u, upper_v,
+ image_width, field_height,
+ image_width, uv_stride, rgb_stride);
+ rgb24toyv12(rgb_buffer_lower, upper_y + low_ofs,
+ upper_u + low_ofs, upper_v + low_ofs,
+ image_width, field_height,
+ image_width, uv_stride, rgb_stride);
+
+ /* Write Y plane */
+ for(i = 0; i < field_height; i++)
+ {
+ vo_y4m_write(upper_y + image_width * i, image_width);
+ vo_y4m_write(upper_y + image_width * i + low_ofs, image_width);
+ }
+
+ /* Write U and V plane */
+ for(i = 0; i < field_height / 2; i++)
+ {
+ vo_y4m_write(upper_u + uv_stride * i, uv_stride);
+ vo_y4m_write(upper_u + uv_stride * i + low_ofs, uv_stride);
+ }
+ for(i = 0; i < field_height / 2; i++)
+ {
+ vo_y4m_write(upper_v + uv_stride * i, uv_stride);
+ vo_y4m_write(upper_v + uv_stride * i + low_ofs, uv_stride);
+ }
+ return; /* Image written; We have to stop here */
+ }
+
+ rgb24toyv12(rgb_buffer, image_y, image_u, image_v,
+ image_width, image_height,
+ image_width, uv_stride, rgb_stride);
+ }
+
+ /* Write progressive frame */
+ vo_y4m_write(image, write_bytes);
}
static uint32_t draw_slice(uint8_t *srcimg[], int stride[], int w,int h,int x,int y)
{
- if(using_format == IMGFMT_YV12)
+ int i;
+ uint8_t *dst, *src = srcimg[0];
+
+ switch (using_format)
{
- int i;
+ case IMGFMT_YV12:
+
// copy Y:
- uint8_t *dst = image_y + image_width * y + x;
- uint8_t *src = srcimg[0];
+ dst = image_y + image_width * y + x;
for (i = 0; i < h; i++)
{
memcpy(dst, src, w);
@@ -141,11 +323,22 @@
dstv += imgstride;
}
}
+ break;
+
+ case IMGFMT_BGR24:
+ case IMGFMT_RGB24:
+ dst = rgb_buffer + (image_width * y + x) * 3;
+ for (i = 0; i < h; i++)
+ {
+ memcpy(dst, src, w * 3);
+ src += stride[0];
+ dst += image_width * 3;
+ }
+ break;
}
return 0;
}
-
static uint32_t draw_frame(uint8_t * src[])
{
switch(using_format)
@@ -153,27 +346,10 @@
case IMGFMT_YV12:
// gets done in draw_slice
break;
+
case IMGFMT_BGR|24:
- {
-#ifdef GUESS_THIS_ISNT_NEEDED
- int c;
- uint8_t temp;
- //switch BGR to RGB
- for(c = 0; c < image_width * image_height; c++)
- {
- temp = src[0][c * 3];
- src[0][c * 3] = src[0][c * 3 + 2];
- src[0][c * 3 + 2] = temp;
- }
-#endif
- }
- // intentional fall-through
case IMGFMT_RGB|24:
- {
- rgb24toyv12(src[0], image_y, image_u, image_v,
- image_width, image_height,
- image_width, image_width / 2, image_width * 3);
- }
+ memcpy(rgb_buffer, src[0], image_width * image_height * 3);
break;
}
return 0;
@@ -181,14 +357,35 @@
static uint32_t query_format(uint32_t format)
{
- switch(format){
- case IMGFMT_YV12:
- return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_OSD;
- case IMGFMT_BGR|24:
- case IMGFMT_RGB|24:
- return VFCAP_CSP_SUPPORTED;
- }
- return 0;
+
+ if (Y4M_IS_INTERLACED)
+ {
+ /* When processing interlaced material we want to get the raw RGB
+ * data and do the YV12 conversion ourselves to have the chrominance
+ * information sampled correct. */
+
+ switch(format)
+ {
+ case IMGFMT_YV12:
+ return VFCAP_CSP_SUPPORTED|VFCAP_OSD;
+ case IMGFMT_BGR|24:
+ case IMGFMT_RGB|24:
+ return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_OSD;
+ }
+ }
+ else
+ {
+
+ switch(format)
+ {
+ case IMGFMT_YV12:
+ return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_OSD;
+ case IMGFMT_BGR|24:
+ case IMGFMT_RGB|24:
+ return VFCAP_CSP_SUPPORTED|VFCAP_OSD;
+ }
+ }
+ return 0;
}
static void uninit(void)
@@ -196,9 +393,18 @@
if(image)
free(image);
image = NULL;
+
if(yuv_out)
fclose(yuv_out);
yuv_out = NULL;
+
+ if(rgb_buffer)
+ free(rgb_buffer);
+ rgb_buffer = NULL;
+
+ if(rgb_line_buffer)
+ free(rgb_line_buffer);
+ rgb_line_buffer = NULL;
}
@@ -209,10 +415,41 @@
static uint32_t preinit(const char *arg)
{
+ int arg_unrecognized = 0;
+
if(arg)
{
- printf("vo_yuv4mpeg: Unknown subdevice: %s\n",arg);
- return ENOSYS;
+ /* configure output mode */
+ if (strcmp(arg, "interlaced"))
+ arg_unrecognized++;
+ else
+ config_interlace = Y4M_ILACE_TOP_FIRST;
+
+ if (strcmp(arg, "interlaced_bf"))
+ arg_unrecognized++;
+ else
+ config_interlace = Y4M_ILACE_BOTTOM_FIRST;
+
+ /* If both tests failed the argument is invalid */
+ if (arg_unrecognized == 2)
+ {
+ printf("vo_yuv4mpeg: Unknown subdevice: %s\n", arg);
+ return ENOSYS;
+ }
+ }
+
+ /* Inform user which output mode is used */
+ switch (config_interlace)
+ {
+ case Y4M_ILACE_TOP_FIRST:
+ printf("vo_yuv4mpeg: Interlaced output mode, top-field first\n");
+ break;
+ case Y4M_ILACE_BOTTOM_FIRST:
+ printf("vo_yuv4mpeg: Interlaced output mode, bottom-field first\n");
+ break;
+ default:
+ printf("vo_yuv4mpeg: Using (default) progressive frame mode\n");
+ break;
}
return 0;
}
More information about the MPlayer-cvslog
mailing list