libvo/vo_yuv4mpeg.c

   1 /*
   2  * yuv4mpeg (mjpegtools) interface
   3  *
   4  * Thrown together by Robert Kesterson <robertk@robertk.com>
   5  * Based on the pgm output plugin, the rgb2rgb postproc filter, divxdec,
   6  * and probably others.
   7  *
   8  * This is undoubtedly incomplete, inaccurate, or just plain wrong. :-)
   9  *
  10  * 2002/06/19 Klaus Stengel <Klaus.Stengel@asamnet.de>
  11  *            - added support for interlaced output
  12  *              Activate by using '-vo yuv4mpeg:interlaced'
  13  *              or '-vo yuv4mpeg:interlaced_bf' if your source has
  14  *              bottom fields first
  15  *            - added some additional checks to catch problems
  16  *
  17  * 2002/04/17 Juergen Hammelmann <juergen.hammelmann@gmx.de>
  18  *            - added support for output of subtitles
  19  *              best, if you give option '-osdlevel 0' to mplayer for
  20  *              no watching the seek+timer
  21  *
  22  * This file is part of MPlayer.
  23  *
  24  * MPlayer is free software; you can redistribute it and/or modify
  25  * it under the terms of the GNU General Public License as published by
  26  * the Free Software Foundation; either version 2 of the License, or
  27  * (at your option) any later version.
  28  *
  29  * MPlayer is distributed in the hope that it will be useful,
  30  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32  * GNU General Public License for more details.
  33  *
  34  * You should have received a copy of the GNU General Public License along
  35  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  36  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  37  */
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <limits.h>
  46
  47 #include "config.h"
  48 #include "subopt-helper.h"
  49 #include "video_out.h"
  50 #include "video_out_internal.h"
  51
  52 #include "mp_msg.h"
  53 #include "help_mp.h"
  54
  55 #include "sub.h"
  56
  57 #include "fastmemcpy.h"
  58 #include "libswscale/swscale.h"
  59 #include "libswscale/rgb2rgb.h"
  60 #include "libmpcodecs/vf_scale.h"
  61 #include "libavutil/rational.h"
  62
  63 static const vo_info_t info =
  64 {
  65         "yuv4mpeg output for mjpegtools",
  66         "yuv4mpeg",
  67         "Robert Kesterson <robertk@robertk.com>",
  68         ""
  69 };
  70
  71 const LIBVO_EXTERN (yuv4mpeg)
  72
  73 static int image_width = 0;
  74 static int image_height = 0;
  75 static float image_fps = 0;
  76
  77 static uint8_t *image = NULL;
  78 static uint8_t *image_y = NULL;
  79 static uint8_t *image_u = NULL;
  80 static uint8_t *image_v = NULL;
  81
  82 static uint8_t *rgb_buffer = NULL;
  83 static uint8_t *rgb_line_buffer = NULL;
  84
  85 static char *yuv_filename = NULL;
  86
  87 static int using_format = 0;
  88 static FILE *yuv_out;
  89 static int write_bytes;
  90
  91 #define Y4M_ILACE_NONE         'p'  /* non-interlaced, progressive frame */
  92 #define Y4M_ILACE_TOP_FIRST    't'  /* interlaced, top-field first       */
  93 #define Y4M_ILACE_BOTTOM_FIRST 'b'  /* interlaced, bottom-field first    */
  94
  95 /* Set progressive mode as default */
  96 static int config_interlace = Y4M_ILACE_NONE;
  97 #define Y4M_IS_INTERLACED (config_interlace != Y4M_ILACE_NONE)
  98
  99 static int config(uint32_t width, uint32_t height, uint32_t d_width,
 100        uint32_t d_height, uint32_t flags, char *title,
 101        uint32_t format)
 102 {
 103         AVRational pixelaspect = av_div_q((AVRational){d_width, d_height},
 104                                           (AVRational){width, height});
 105         AVRational fps_frac = av_d2q(vo_fps, vo_fps * 1001 + 2);
 106         if (image_width == width && image_height == height &&
 107              image_fps == vo_fps && vo_config_count)
 108           return 0;
 109         if (vo_config_count) {
 110           mp_msg(MSGT_VO, MSGL_WARN,
 111             "Video formats differ (w:%i=>%i, h:%i=>%i, fps:%f=>%f), "
 112             "restarting output.\n",
 113             image_width, width, image_height, height, image_fps, vo_fps);
 114           uninit();
 115         }
 116         image_height = height;
 117         image_width = width;
 118         image_fps = vo_fps;
 119         using_format = format;
 120
 121         if (Y4M_IS_INTERLACED)
 122         {
 123                 if (height % 4)
 124                 {
 125                         mp_tmsg(MSGT_VO,MSGL_FATAL,
 126                                 "Interlaced mode requires image height to be divisible by 4.");
 127                         return -1;
 128                 }
 129
 130                 rgb_line_buffer = malloc(image_width * 3);
 131                 if (!rgb_line_buffer)
 132                 {
 133                         mp_tmsg(MSGT_VO,MSGL_FATAL,
 134                                 "Unable to allocate line buffer for interlaced mode.");
 135                         return -1;
 136                 }
 137
 138                 if (using_format == IMGFMT_YV12)
 139                         mp_tmsg(MSGT_VO,MSGL_WARN,
 140                                 "Input not RGB, can't separate chrominance by fields!");
 141         }
 142
 143         if (width % 2)
 144         {
 145                 mp_tmsg(MSGT_VO,MSGL_FATAL,
 146                         "Image width must be divisible by 2.");
 147                 return -1;
 148         }
 149
 150         if(using_format != IMGFMT_YV12)
 151         {
 152                 sws_rgb2rgb_init(get_sws_cpuflags());
 153                 rgb_buffer = malloc(image_width * image_height * 3);
 154                 if (!rgb_buffer)
 155                 {
 156                         mp_tmsg(MSGT_VO,MSGL_FATAL,
 157                                 "Not enough memory to allocate RGB framebuffer.");
 158                         return -1;
 159                 }
 160         }
 161
 162         write_bytes = image_width * image_height * 3 / 2;
 163         image = malloc(write_bytes);
 164
 165         yuv_out = fopen(yuv_filename, "wb");
 166         if (!yuv_out || image == 0)
 167         {
 168                 mp_tmsg(MSGT_VO,MSGL_FATAL,
 169                         "Can't get memory or file handle to write \"%s\"!",
 170                         yuv_filename);
 171                 return -1;
 172         }
 173         image_y = image;
 174         image_u = image_y + image_width * image_height;
 175         image_v = image_u + image_width * image_height / 4;
 176
 177         fprintf(yuv_out, "YUV4MPEG2 W%d H%d F%d:%d I%c A%d:%d\n",
 178                         image_width, image_height, fps_frac.num, fps_frac.den,
 179                         config_interlace,
 180                         pixelaspect.num, pixelaspect.den);
 181
 182         fflush(yuv_out);
 183         return 0;
 184 }
 185
 186 /* Only use when h divisable by 2! */
 187 static void swap_fields(uint8_t *ptr, const int h, const int stride)
 188 {
 189         int i;
 190
 191         for (i=0; i<h; i +=2)
 192         {
 193                 fast_memcpy(rgb_line_buffer     , ptr + stride *  i   , stride);
 194                 fast_memcpy(ptr + stride *  i   , ptr + stride * (i+1), stride);
 195                 fast_memcpy(ptr + stride * (i+1), rgb_line_buffer     , stride);
 196         }
 197 }
 198
 199 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
 200                        unsigned char *srca, int stride) {
 201         switch (using_format)
 202         {
 203         case IMGFMT_YV12:
 204                 vo_draw_alpha_yv12(w, h, src, srca, stride,
 205                                        image + y0 * image_width + x0, image_width);
 206                         break;
 207
 208                 case IMGFMT_BGR|24:
 209                 case IMGFMT_RGB|24:
 210                         if (config_interlace != Y4M_ILACE_BOTTOM_FIRST)
 211                                 vo_draw_alpha_rgb24(w, h, src, srca, stride,
 212                                                 rgb_buffer + (y0 * image_width + x0) * 3, image_width * 3);
 213                         else
 214                         {
 215                                 swap_fields (rgb_buffer, image_height, image_width * 3);
 216
 217                                 vo_draw_alpha_rgb24(w, h, src, srca, stride,
 218                                                 rgb_buffer + (y0 * image_width  + x0) * 3, image_width * 3);
 219
 220                                 swap_fields (rgb_buffer, image_height, image_width * 3);
 221                         }
 222                         break;
 223         }
 224 }
 225
 226 static void draw_osd(void)
 227 {
 228     vo_draw_text(image_width, image_height, draw_alpha);
 229 }
 230
 231 static void deinterleave_fields(uint8_t *ptr, const int stride,
 232                                                           const int img_height)
 233 {
 234         unsigned int i, j, k_start = 1, modv = img_height - 1;
 235         unsigned char *line_state = malloc(modv);
 236
 237         for (i=0; i<modv; i++)
 238                 line_state[i] = 0;
 239
 240         line_state[0] = 1;
 241
 242         while(k_start < modv)
 243         {
 244                 i = j = k_start;
 245                 fast_memcpy(rgb_line_buffer, ptr + stride * i, stride);
 246
 247                 while (!line_state[j])
 248                 {
 249                         line_state[j] = 1;
 250                         i = j;
 251                         j = j * 2 % modv;
 252                         fast_memcpy(ptr + stride * i, ptr + stride * j, stride);
 253                 }
 254                 fast_memcpy(ptr + stride * i, rgb_line_buffer, stride);
 255
 256                 while(k_start < modv && line_state[k_start])
 257                         k_start++;
 258         }
 259         free(line_state);
 260 }
 261
 262 static void vo_y4m_write(const void *ptr, const size_t num_bytes)
 263 {
 264         if (fwrite(ptr, 1, num_bytes, yuv_out) != num_bytes)
 265                 mp_tmsg(MSGT_VO,MSGL_ERR,
 266                         "Error writing image to output!");
 267 }
 268
 269 static int write_last_frame(void)
 270 {
 271
 272     uint8_t *upper_y, *upper_u, *upper_v, *rgb_buffer_lower;
 273     int rgb_stride, uv_stride, field_height;
 274     unsigned int i, low_ofs;
 275
 276     fprintf(yuv_out, "FRAME\n");
 277
 278     if (using_format != IMGFMT_YV12)
 279     {
 280         rgb_stride = image_width * 3;
 281         uv_stride = image_width / 2;
 282
 283         if (Y4M_IS_INTERLACED)
 284         {
 285             field_height = image_height / 2;
 286
 287             upper_y = image;
 288             upper_u = upper_y + image_width * field_height;
 289             upper_v = upper_u + image_width * field_height / 4;
 290             low_ofs = image_width * field_height * 3 / 2;
 291             rgb_buffer_lower = rgb_buffer + rgb_stride * field_height;
 292
 293             /* Write Y plane */
 294             for(i = 0; i < field_height; i++)
 295             {
 296                 vo_y4m_write(upper_y + image_width * i,           image_width);
 297                 vo_y4m_write(upper_y + image_width * i + low_ofs, image_width);
 298             }
 299
 300             /* Write U and V plane */
 301             for(i = 0; i < field_height / 2; i++)
 302             {
 303                 vo_y4m_write(upper_u + uv_stride * i,           uv_stride);
 304                 vo_y4m_write(upper_u + uv_stride * i + low_ofs, uv_stride);
 305             }
 306             for(i = 0; i < field_height / 2; i++)
 307             {
 308                 vo_y4m_write(upper_v + uv_stride * i,           uv_stride);
 309                 vo_y4m_write(upper_v + uv_stride * i + low_ofs, uv_stride);
 310             }
 311             return VO_TRUE; /* Image written; We have to stop here */
 312         }
 313     }
 314     /* Write progressive frame */
 315     vo_y4m_write(image, write_bytes);
 316     return VO_TRUE;
 317 }
 318
 319 static void flip_page (void)
 320 {
 321         uint8_t *upper_y, *upper_u, *upper_v, *rgb_buffer_lower;
 322         int rgb_stride, uv_stride, field_height;
 323         unsigned int i, low_ofs;
 324
 325         fprintf(yuv_out, "FRAME\n");
 326
 327         if (using_format != IMGFMT_YV12)
 328         {
 329                 rgb_stride = image_width * 3;
 330                 uv_stride = image_width / 2;
 331
 332                 if (Y4M_IS_INTERLACED)
 333                 {
 334                         field_height = image_height / 2;
 335
 336                         upper_y = image;
 337                         upper_u = upper_y + image_width * field_height;
 338                         upper_v = upper_u + image_width * field_height / 4;
 339                         low_ofs = image_width * field_height * 3 / 2;
 340                         rgb_buffer_lower = rgb_buffer + rgb_stride * field_height;
 341
 342                         deinterleave_fields(rgb_buffer, rgb_stride, image_height);
 343
 344                         rgb24toyv12(rgb_buffer, upper_y, upper_u, upper_v,
 345                                                  image_width, field_height,
 346                                                  image_width, uv_stride, rgb_stride);
 347                         rgb24toyv12(rgb_buffer_lower,  upper_y + low_ofs,
 348                                                  upper_u + low_ofs, upper_v + low_ofs,
 349                                                  image_width, field_height,
 350                                                  image_width, uv_stride, rgb_stride);
 351
 352                         /* Write Y plane */
 353                         for(i = 0; i < field_height; i++)
 354                         {
 355                                 vo_y4m_write(upper_y + image_width * i,           image_width);
 356                                 vo_y4m_write(upper_y + image_width * i + low_ofs, image_width);
 357                         }
 358
 359                         /* Write U and V plane */
 360                         for(i = 0; i < field_height / 2; i++)
 361                         {
 362                                 vo_y4m_write(upper_u + uv_stride * i,           uv_stride);
 363                                 vo_y4m_write(upper_u + uv_stride * i + low_ofs, uv_stride);
 364                         }
 365                         for(i = 0; i < field_height / 2; i++)
 366                         {
 367                                 vo_y4m_write(upper_v + uv_stride * i,           uv_stride);
 368                                 vo_y4m_write(upper_v + uv_stride * i + low_ofs, uv_stride);
 369                         }
 370                         return; /* Image written; We have to stop here */
 371                 }
 372
 373                 rgb24toyv12(rgb_buffer, image_y, image_u, image_v,
 374                                         image_width, image_height,
 375                                         image_width, uv_stride, rgb_stride);
 376         }
 377
 378         /* Write progressive frame */
 379         vo_y4m_write(image, write_bytes);
 380 }
 381
 382 static int draw_slice(uint8_t *srcimg[], int stride[], int w,int h,int x,int y)
 383 {
 384         int i;
 385         uint8_t *dst, *src = srcimg[0];
 386
 387         switch (using_format)
 388         {
 389                 case IMGFMT_YV12:
 390
 391                 // copy Y:
 392                 dst = image_y + image_width * y + x;
 393                 for (i = 0; i < h; i++)
 394                 {
 395                         fast_memcpy(dst, src, w);
 396                         src += stride[0];
 397                         dst += image_width;
 398                 }
 399                 {
 400                         // copy U + V:
 401                         int imgstride = image_width >> 1;
 402                         uint8_t *src1 = srcimg[1];
 403                         uint8_t *src2 = srcimg[2];
 404                         uint8_t *dstu = image_u + imgstride * (y >> 1) + (x >> 1);
 405                         uint8_t *dstv = image_v + imgstride * (y >> 1) + (x >> 1);
 406                         for (i = 0; i < h / 2; i++)
 407                         {
 408                                 fast_memcpy(dstu, src1 , w >> 1);
 409                                 fast_memcpy(dstv, src2, w >> 1);
 410                                 src1 += stride[1];
 411                                 src2 += stride[2];
 412                                 dstu += imgstride;
 413                                 dstv += imgstride;
 414                         }
 415                 }
 416                 break;
 417
 418                 case IMGFMT_BGR24:
 419                 case IMGFMT_RGB24:
 420                         dst = rgb_buffer + (image_width * y + x) * 3;
 421                         for (i = 0; i < h; i++)
 422                         {
 423                                 fast_memcpy(dst, src, w * 3);
 424                                 src += stride[0];
 425                                 dst += image_width * 3;
 426                         }
 427                         break;
 428         }
 429         return 0;
 430 }
 431
 432 static int draw_frame(uint8_t * src[])
 433 {
 434         switch(using_format)
 435         {
 436                 case IMGFMT_YV12:
 437                         // gets done in draw_slice
 438                         break;
 439
 440                 case IMGFMT_BGR24:
 441                 case IMGFMT_RGB24:
 442                         fast_memcpy(rgb_buffer, src[0], image_width * image_height * 3);
 443                         break;
 444         }
 445     return 0;
 446 }
 447
 448 static int query_format(uint32_t format)
 449 {
 450
 451         if (Y4M_IS_INTERLACED)
 452     {
 453                 /* When processing interlaced material we want to get the raw RGB
 454          * data and do the YV12 conversion ourselves to have the chrominance
 455          * information sampled correct. */
 456
 457                 switch(format)
 458                 {
 459                         case IMGFMT_YV12:
 460                                 return VFCAP_CSP_SUPPORTED|VFCAP_OSD|VFCAP_ACCEPT_STRIDE;
 461                         case IMGFMT_BGR|24:
 462                         case IMGFMT_RGB|24:
 463                                 return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_OSD|VFCAP_ACCEPT_STRIDE;
 464                 }
 465         }
 466         else
 467         {
 468
 469                 switch(format)
 470                 {
 471                         case IMGFMT_YV12:
 472                                 return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_OSD|VFCAP_ACCEPT_STRIDE;
 473                 case IMGFMT_BGR|24:
 474                 case IMGFMT_RGB|24:
 475                         return VFCAP_CSP_SUPPORTED|VFCAP_OSD|VFCAP_ACCEPT_STRIDE;
 476         }
 477         }
 478         return 0;
 479 }
 480
 481 // WARNING: config(...) also uses this
 482 static void uninit(void)
 483 {
 484     if(image)
 485                 free(image);
 486         image = NULL;
 487
 488         if(yuv_out)
 489                 fclose(yuv_out);
 490         yuv_out = NULL;
 491
 492         if(rgb_buffer)
 493                 free(rgb_buffer);
 494         rgb_buffer = NULL;
 495
 496         if(rgb_line_buffer)
 497                 free(rgb_line_buffer);
 498         rgb_line_buffer = NULL;
 499
 500         if (yuv_filename)
 501                 free(yuv_filename);
 502         yuv_filename = NULL;
 503         image_width = 0;
 504         image_height = 0;
 505         image_fps = 0;
 506 }
 507
 508
 509 static void check_events(void)
 510 {
 511 }
 512
 513 static int preinit(const char *arg)
 514 {
 515   int il, il_bf;
 516   const opt_t subopts[] = {
 517     {"interlaced",    OPT_ARG_BOOL, &il,    NULL},
 518     {"interlaced_bf", OPT_ARG_BOOL, &il_bf, NULL},
 519     {"file",          OPT_ARG_MSTRZ,  &yuv_filename,  NULL},
 520     {NULL}
 521   };
 522
 523   il = 0;
 524   il_bf = 0;
 525   yuv_filename = strdup("stream.yuv");
 526   if (subopt_parse(arg, subopts) != 0) {
 527     mp_tmsg(MSGT_VO, MSGL_FATAL, "Unknown subdevice: %s", arg);
 528     return -1;
 529   }
 530
 531   config_interlace = Y4M_ILACE_NONE;
 532   if (il)
 533     config_interlace = Y4M_ILACE_TOP_FIRST;
 534   if (il_bf)
 535     config_interlace = Y4M_ILACE_BOTTOM_FIRST;
 536
 537     /* Inform user which output mode is used */
 538     switch (config_interlace)
 539     {
 540         case Y4M_ILACE_TOP_FIRST:
 541             mp_tmsg(MSGT_VO,MSGL_STATUS,
 542                     "Using interlaced output mode, top-field first.");
 543             break;
 544         case Y4M_ILACE_BOTTOM_FIRST:
 545             mp_tmsg(MSGT_VO,MSGL_STATUS,
 546                     "Using interlaced output mode, bottom-field first.");
 547             break;
 548         default:
 549             mp_tmsg(MSGT_VO,MSGL_STATUS,
 550                     "Using (default) progressive frame mode.");
 551             break;
 552     }
 553     return 0;
 554 }
 555
 556 static int control(uint32_t request, void *data)
 557 {
 558   switch (request) {
 559   case VOCTRL_QUERY_FORMAT:
 560     return query_format(*((uint32_t*)data));
 561   case VOCTRL_DUPLICATE_FRAME:
 562     return write_last_frame();
 563   }
 564   return VO_NOTIMPL;
 565 }