libvo/vo_jpeg.c

   1 /* ------------------------------------------------------------------------- */
   2
   3 /*
   4  * vo_jpeg.c, JPEG Renderer for MPlayer
   5  *
   6  * Copyright (C) 2002 by Pontscho <pontscho@makacs.poliod.hu>
   7  * Copyright (C) 2003 by Alex
   8  * Copyright (C) 2004, 2005 by Ivo van Poorten <ivop@euronet.nl>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  *
  24  */
  25
  26 /* ------------------------------------------------------------------------- */
  27
  28 /* Global Includes */
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <jpeglib.h>
  35 #include <sys/stat.h>
  36 #include <sys/types.h>
  37 #include <unistd.h>
  38
  39 /* ------------------------------------------------------------------------- */
  40
  41 /* Local Includes */
  42
  43 #include "config.h"
  44 #include "subopt-helper.h"
  45 #include "mp_msg.h"
  46 #include "video_out.h"
  47 #include "video_out_internal.h"
  48 #include "mplayer.h"                    /* for exit_player() */
  49 #include "help_mp.h"
  50
  51 /* ------------------------------------------------------------------------- */
  52
  53 /* Defines */
  54
  55 /* Used for temporary buffers to store file- and pathnames */
  56 #define BUFLENGTH 512
  57
  58 /* ------------------------------------------------------------------------- */
  59
  60 /* Info */
  61
  62 static const vo_info_t info=
  63 {
  64         "JPEG file",
  65         "jpeg",
  66         "Zoltan Ponekker (pontscho@makacs.poliod.hu)",
  67         ""
  68 };
  69
  70 const LIBVO_EXTERN (jpeg)
  71
  72 /* ------------------------------------------------------------------------- */
  73
  74 /* Global Variables */
  75
  76 static int image_width;
  77 static int image_height;
  78 static int image_d_width;
  79 static int image_d_height;
  80
  81 int jpeg_baseline = 1;
  82 int jpeg_progressive_mode = 0;
  83 int jpeg_optimize = 100;
  84 int jpeg_smooth = 0;
  85 int jpeg_quality = 75;
  86 int jpeg_dpi = 72; /** Screen resolution = 72 dpi */
  87 char *jpeg_outdir = NULL;
  88 char *jpeg_subdirs = NULL;
  89 int jpeg_maxfiles = 1000;
  90
  91 static int framenum = 0;
  92
  93 /* ------------------------------------------------------------------------- */
  94
  95 /** \brief Create a directory.
  96  *
  97  *  This function creates a directory. If it already exists, it tests if
  98  *  it's a directory and not something else, and if it is, it tests whether
  99  *  the directory is writable or not.
 100  *
 101  * \param buf       Pointer to directory name.
 102  * \param verbose   Verbose on success. If verbose is non-zero, it will print
 103  *                  a message if it was successful in creating the directory.
 104  *
 105  * \return nothing  In case anything fails, the player will exit. If it
 106  *                  returns, everything went well.
 107  */
 108
 109 static void jpeg_mkdir(char *buf, int verbose) {
 110     struct stat stat_p;
 111
 112 #ifndef __MINGW32__
 113     if ( mkdir(buf, 0755) < 0 ) {
 114 #else
 115     if ( mkdir(buf) < 0 ) {
 116 #endif
 117         switch (errno) { /* use switch in case other errors need to be caught
 118                             and handled in the future */
 119             case EEXIST:
 120                 if ( stat(buf, &stat_p ) < 0 ) {
 121                     mp_msg(MSGT_VO, MSGL_ERR, "%s: %s: %s\n", info.short_name,
 122                             MSGTR_VO_GenericError, strerror(errno) );
 123                     mp_msg(MSGT_VO, MSGL_ERR, "%s: %s %s\n", info.short_name,
 124                             MSGTR_VO_UnableToAccess,buf);
 125                     exit_player(MSGTR_Exit_error);
 126                 }
 127                 if ( !S_ISDIR(stat_p.st_mode) ) {
 128                     mp_msg(MSGT_VO, MSGL_ERR, "%s: %s %s\n", info.short_name,
 129                             buf, MSGTR_VO_ExistsButNoDirectory);
 130                     exit_player(MSGTR_Exit_error);
 131                 }
 132                 if ( !(stat_p.st_mode & S_IWUSR) ) {
 133                     mp_msg(MSGT_VO, MSGL_ERR, "%s: %s - %s\n", info.short_name,
 134                             buf, MSGTR_VO_DirExistsButNotWritable);
 135                     exit_player(MSGTR_Exit_error);
 136                 }
 137
 138                 mp_msg(MSGT_VO, MSGL_INFO, "%s: %s - %s\n", info.short_name,
 139                         buf, MSGTR_VO_DirExistsAndIsWritable);
 140                 break;
 141
 142             default:
 143                 mp_msg(MSGT_VO, MSGL_ERR, "%s: %s: %s\n", info.short_name,
 144                         MSGTR_VO_GenericError, strerror(errno) );
 145                 mp_msg(MSGT_VO, MSGL_ERR, "%s: %s - %s\n", info.short_name,
 146                         buf, MSGTR_VO_CantCreateDirectory);
 147                 exit_player(MSGTR_Exit_error);
 148         } /* end switch */
 149     } else if ( verbose ) {
 150         mp_msg(MSGT_VO, MSGL_INFO, "%s: %s - %s\n", info.short_name,
 151                 buf, MSGTR_VO_DirectoryCreateSuccess);
 152     } /* end if */
 153 }
 154
 155 /* ------------------------------------------------------------------------- */
 156
 157 static int config(uint32_t width, uint32_t height, uint32_t d_width,
 158                        uint32_t d_height, uint32_t flags, char *title,
 159                        uint32_t format)
 160 {
 161     char buf[BUFLENGTH];
 162
 163     /* Create outdir. */
 164
 165     snprintf(buf, BUFLENGTH, "%s", jpeg_outdir);
 166
 167     jpeg_mkdir(buf, 1); /* This function only returns if creation was
 168                            successful. If not, the player will exit. */
 169
 170     image_height = height;
 171     image_width = width;
 172     /* Save for JFIF-Header PAR */
 173     image_d_width = d_width;
 174     image_d_height = d_height;
 175
 176     return 0;
 177 }
 178
 179 /* ------------------------------------------------------------------------- */
 180
 181 static uint32_t jpeg_write(uint8_t * name, uint8_t * buffer)
 182 {
 183     FILE *outfile;
 184     struct jpeg_compress_struct cinfo;
 185     struct jpeg_error_mgr jerr;
 186     JSAMPROW row_pointer[1];
 187     int row_stride;
 188
 189     if ( !buffer ) return 1;
 190     if ( (outfile = fopen(name, "wb") ) == NULL ) {
 191         mp_msg(MSGT_VO, MSGL_ERR, "\n%s: %s\n", info.short_name,
 192                 MSGTR_VO_CantCreateFile);
 193         mp_msg(MSGT_VO, MSGL_ERR, "%s: %s: %s\n",
 194                 info.short_name, MSGTR_VO_GenericError,
 195                 strerror(errno) );
 196         exit_player(MSGTR_Exit_error);
 197     }
 198
 199     cinfo.err = jpeg_std_error(&jerr);
 200     jpeg_create_compress(&cinfo);
 201     jpeg_stdio_dest(&cinfo, outfile);
 202
 203     cinfo.image_width = image_width;
 204     cinfo.image_height = image_height;
 205     cinfo.input_components = 3;
 206     cinfo.in_color_space = JCS_RGB;
 207
 208     jpeg_set_defaults(&cinfo);
 209     /* Important: Header info must be set AFTER jpeg_set_defaults() */
 210     cinfo.write_JFIF_header = TRUE;
 211     cinfo.JFIF_major_version = 1;
 212     cinfo.JFIF_minor_version = 2;
 213     cinfo.density_unit = 1; /* 0=unknown, 1=dpi, 2=dpcm */
 214     /* Image DPI is determined by Y_density, so we leave that at
 215        jpeg_dpi if possible and crunch X_density instead (PAR > 1) */
 216     cinfo.X_density = jpeg_dpi*image_width/image_d_width;
 217     cinfo.Y_density = jpeg_dpi*image_height/image_d_height;
 218     cinfo.write_Adobe_marker = TRUE;
 219
 220     jpeg_set_quality(&cinfo,jpeg_quality, jpeg_baseline);
 221     cinfo.optimize_coding = jpeg_optimize;
 222     cinfo.smoothing_factor = jpeg_smooth;
 223
 224     if ( jpeg_progressive_mode ) {
 225         jpeg_simple_progression(&cinfo);
 226     }
 227
 228     jpeg_start_compress(&cinfo, TRUE);
 229
 230     row_stride = image_width * 3;
 231     while (cinfo.next_scanline < cinfo.image_height) {
 232         row_pointer[0] = &buffer[cinfo.next_scanline * row_stride];
 233         (void)jpeg_write_scanlines(&cinfo, row_pointer,1);
 234     }
 235
 236     jpeg_finish_compress(&cinfo);
 237     fclose(outfile);
 238     jpeg_destroy_compress(&cinfo);
 239
 240     return 0;
 241 }
 242
 243 /* ------------------------------------------------------------------------- */
 244
 245 static int draw_frame(uint8_t *src[])
 246 {
 247     static int framecounter = 0, subdircounter = 0;
 248     char buf[BUFLENGTH];
 249     static char subdirname[BUFLENGTH] = "";
 250
 251     /* Start writing to new subdirectory after a certain amount of frames */
 252     if ( framecounter == jpeg_maxfiles ) {
 253         framecounter = 0;
 254     }
 255
 256     /* If framecounter is zero (or reset to zero), increment subdirectory
 257      * number and create the subdirectory.
 258      * If jpeg_subdirs is not set, do nothing and resort to old behaviour. */
 259     if ( !framecounter && jpeg_subdirs ) {
 260         subdircounter++;
 261         snprintf(subdirname, BUFLENGTH, "%s%08d", jpeg_subdirs, subdircounter);
 262         snprintf(buf, BUFLENGTH, "%s/%s", jpeg_outdir, subdirname);
 263         jpeg_mkdir(buf, 0); /* This function only returns if creation was
 264                                successful. If not, the player will exit. */
 265     }
 266
 267     framenum++;
 268
 269     /* snprintf the full pathname of the outputfile */
 270     snprintf(buf, BUFLENGTH, "%s/%s/%08d.jpg", jpeg_outdir, subdirname,
 271                                                                     framenum);
 272
 273     framecounter++;
 274
 275     return jpeg_write(buf, src[0]);
 276 }
 277
 278 /* ------------------------------------------------------------------------- */
 279
 280 static void draw_osd(void)
 281 {
 282 }
 283
 284 /* ------------------------------------------------------------------------- */
 285
 286 static void flip_page (void)
 287 {
 288 }
 289
 290 /* ------------------------------------------------------------------------- */
 291
 292 static int draw_slice(uint8_t *src[], int stride[], int w, int h,
 293                            int x, int y)
 294 {
 295     return 0;
 296 }
 297
 298 /* ------------------------------------------------------------------------- */
 299
 300 static int query_format(uint32_t format)
 301 {
 302     if (format == IMGFMT_RGB24) {
 303         return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW;
 304     }
 305
 306     return 0;
 307 }
 308
 309 /* ------------------------------------------------------------------------- */
 310
 311 static void uninit(void)
 312 {
 313     if (jpeg_subdirs) {
 314         free(jpeg_subdirs);
 315         jpeg_subdirs = NULL;
 316     }
 317     if (jpeg_outdir) {
 318         free(jpeg_outdir);
 319         jpeg_outdir = NULL;
 320     }
 321 }
 322
 323 /* ------------------------------------------------------------------------- */
 324
 325 static void check_events(void)
 326 {
 327 }
 328
 329 /* ------------------------------------------------------------------------- */
 330
 331 /** \brief Validation function for values [0-100]
 332  */
 333
 334 static int int_zero_hundred(int *val)
 335 {
 336     if ( (*val >=0) && (*val<=100) )
 337         return 1;
 338     return 0;
 339 }
 340
 341 static int preinit(const char *arg)
 342 {
 343     opt_t subopts[] = {
 344         {"progressive", OPT_ARG_BOOL,   &jpeg_progressive_mode, NULL, 0},
 345         {"baseline",    OPT_ARG_BOOL,   &jpeg_baseline,         NULL, 0},
 346         {"optimize",    OPT_ARG_INT,    &jpeg_optimize,
 347                                             (opt_test_f)int_zero_hundred, 0},
 348         {"smooth",      OPT_ARG_INT,    &jpeg_smooth,
 349                                             (opt_test_f)int_zero_hundred, 0},
 350         {"quality",     OPT_ARG_INT,    &jpeg_quality,
 351                                             (opt_test_f)int_zero_hundred, 0},
 352         {"dpi",         OPT_ARG_INT,    &jpeg_dpi,              NULL, 0},
 353         {"outdir",      OPT_ARG_MSTRZ,  &jpeg_outdir,           NULL, 0},
 354         {"subdirs",     OPT_ARG_MSTRZ,  &jpeg_subdirs,          NULL, 0},
 355         {"maxfiles",    OPT_ARG_INT,    &jpeg_maxfiles, (opt_test_f)int_pos, 0},
 356         {NULL, 0, NULL, NULL, 0}
 357     };
 358     const char *info_message = NULL;
 359
 360     mp_msg(MSGT_VO, MSGL_INFO, "%s: %s\n", info.short_name,
 361                                             MSGTR_VO_ParsingSuboptions);
 362
 363     jpeg_progressive_mode = 0;
 364     jpeg_baseline = 1;
 365     jpeg_optimize = 100;
 366     jpeg_smooth = 0;
 367     jpeg_quality = 75;
 368     jpeg_maxfiles = 1000;
 369     jpeg_outdir = strdup(".");
 370     jpeg_subdirs = NULL;
 371
 372     if (subopt_parse(arg, subopts) != 0) {
 373         return -1;
 374     }
 375
 376     if (jpeg_progressive_mode) info_message = MSGTR_VO_JPEG_ProgressiveJPEG;
 377     else info_message = MSGTR_VO_JPEG_NoProgressiveJPEG;
 378     mp_msg(MSGT_VO, MSGL_INFO, "%s: %s\n", info.short_name, info_message);
 379
 380     if (jpeg_baseline) info_message = MSGTR_VO_JPEG_BaselineJPEG;
 381     else info_message = MSGTR_VO_JPEG_NoBaselineJPEG;
 382     mp_msg(MSGT_VO, MSGL_INFO, "%s: %s\n", info.short_name, info_message);
 383
 384     mp_msg(MSGT_VO, MSGL_V, "%s: optimize --> %d\n", info.short_name,
 385                                                                 jpeg_optimize);
 386     mp_msg(MSGT_VO, MSGL_V, "%s: smooth --> %d\n", info.short_name,
 387                                                                 jpeg_smooth);
 388     mp_msg(MSGT_VO, MSGL_V, "%s: quality --> %d\n", info.short_name,
 389                                                                 jpeg_quality);
 390     mp_msg(MSGT_VO, MSGL_V, "%s: dpi --> %d\n", info.short_name,
 391                                                                 jpeg_dpi);
 392     mp_msg(MSGT_VO, MSGL_V, "%s: outdir --> %s\n", info.short_name,
 393                                                                 jpeg_outdir);
 394     if (jpeg_subdirs) {
 395         mp_msg(MSGT_VO, MSGL_V, "%s: subdirs --> %s\n", info.short_name,
 396                                                                 jpeg_subdirs);
 397         mp_msg(MSGT_VO, MSGL_V, "%s: maxfiles --> %d\n", info.short_name,
 398                                                                 jpeg_maxfiles);
 399     }
 400
 401     mp_msg(MSGT_VO, MSGL_INFO, "%s: %s\n", info.short_name,
 402                                             MSGTR_VO_SuboptionsParsedOK);
 403     return 0;
 404 }
 405
 406 /* ------------------------------------------------------------------------- */
 407
 408 static int control(uint32_t request, void *data, ...)
 409 {
 410     switch (request) {
 411         case VOCTRL_QUERY_FORMAT:
 412             return query_format(*((uint32_t*)data));
 413     }
 414     return VO_NOTIMPL;
 415 }
 416
 417 /* ------------------------------------------------------------------------- */
 418
 419 #undef BUFLENGTH
 420
 421 /* ------------------------------------------------------------------------- */
 422