libvo/vo_md5sum.c

   1 /* ------------------------------------------------------------------------- */
   2
   3 /*
   4  * md5sum video output driver
   5  *
   6  * Copyright (C) 2004, 2005, 2006 Ivo van Poorten
   7  *
   8  * This file is part of MPlayer.
   9  *
  10  * MPlayer is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * MPlayer 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 along
  21  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  23  */
  24
  25 /* ------------------------------------------------------------------------- */
  26
  27 /* Global Includes */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <errno.h>
  33
  34 /* ------------------------------------------------------------------------- */
  35
  36 /* Local Includes */
  37
  38 #include "config.h"
  39 #include "subopt-helper.h"
  40 #include "mp_msg.h"
  41 #include "video_out.h"
  42 #include "video_out_internal.h"
  43 #include "mplayer.h"                    /* for exit_player_bad() */
  44 #include "libavutil/md5.h"
  45
  46 /* ------------------------------------------------------------------------- */
  47
  48 /* Info */
  49
  50 static const vo_info_t info=
  51 {
  52         "md5sum of each frame",
  53         "md5sum",
  54         "Ivo van Poorten (ivop@euronet.nl)",
  55         ""
  56 };
  57
  58 const LIBVO_EXTERN (md5sum)
  59
  60 /* ------------------------------------------------------------------------- */
  61
  62 /* Global Variables */
  63
  64 char *md5sum_outfile = NULL;
  65
  66 FILE *md5sum_fd;
  67 int framenum = 0;
  68
  69 /* ------------------------------------------------------------------------- */
  70
  71 /** \brief An error occured while writing to a file.
  72  *
  73  * The program failed to write data to a file.
  74  * It displays a message and exits the player.
  75  *
  76  * \return nothing It does not return.
  77  */
  78
  79 static void md5sum_write_error(void) {
  80     mp_tmsg(MSGT_VO, MSGL_ERR, "%s: Error writing file.\n", info.short_name);
  81     exit_player_bad(_("Fatal error"));
  82 }
  83
  84 /* ------------------------------------------------------------------------- */
  85
  86 /** \brief Pre-initialisation.
  87  *
  88  * This function is called before initialising the video output driver. It
  89  * parses all suboptions and sets variables accordingly. If an error occurs
  90  * (like an option being out of range, not having any value or an unknown
  91  * option is stumbled upon) the player will exit. It also sets default
  92  * values if necessary.
  93  *
  94  * \param arg   A string containing all the suboptions passed to the video
  95  *              output driver.
  96  *
  97  * \return 0    All went well.
  98  */
  99
 100 static int preinit(const char *arg)
 101 {
 102     const opt_t subopts[] = {
 103         {"outfile",     OPT_ARG_MSTRZ,    &md5sum_outfile,   NULL},
 104         {NULL, 0, NULL, NULL}
 105     };
 106
 107     mp_msg(MSGT_VO, MSGL_V, "%s: %s\n", info.short_name,
 108            "Parsing suboptions.");
 109
 110     md5sum_outfile = strdup("md5sums");
 111     if (subopt_parse(arg, subopts) != 0) {
 112         return -1;
 113     }
 114
 115     mp_msg(MSGT_VO, MSGL_V, "%s: outfile --> %s\n", info.short_name,
 116                                                             md5sum_outfile);
 117
 118     mp_msg(MSGT_VO, MSGL_V, "%s: %s\n", info.short_name,
 119            "Suboptions parsed OK.");
 120     return 0;
 121 }
 122
 123 /* ------------------------------------------------------------------------- */
 124
 125 /** \brief Configure the video output driver.
 126  *
 127  * This functions configures the video output driver. It opens the output
 128  * file to which this driver will write all the MD5 sums. If something
 129  * goes wrong, the player will exit.
 130  *
 131  *  \return 0             All went well.
 132  */
 133
 134 static int config(uint32_t width, uint32_t height, uint32_t d_width,
 135                        uint32_t d_height, uint32_t flags, char *title,
 136                        uint32_t format)
 137 {
 138     if (vo_config_count > 0 ) { /* Already configured */
 139         return 0;
 140     }
 141
 142     if ( (md5sum_fd = fopen(md5sum_outfile, "w") ) == NULL ) {
 143         mp_msg(MSGT_VO, MSGL_ERR, "\n%s: %s\n", info.short_name,
 144                _("Unable to create output file."));
 145         mp_msg(MSGT_VO, MSGL_ERR, "%s: %s: %s\n",
 146                info.short_name, _("This error has occurred"), strerror(errno) );
 147         exit_player_bad(_("Fatal error"));
 148     }
 149
 150     return 0;
 151 }
 152
 153 /* ------------------------------------------------------------------------- */
 154
 155 /** \brief Write MD5 sum to output file.
 156  *
 157  * This function writes an ASCII representation of a 16-byte hexadecimal
 158  * MD5 sum to our output file. The file descriptor is a global variable.
 159  *
 160  * \param md5sum Sixteen bytes that represent an MD5 sum.
 161  *
 162  * \return None     The player will exit if a write error occurs.
 163  */
 164
 165 static void md5sum_output_sum(unsigned char *md5sum) {
 166     int i;
 167
 168     for(i=0; i<16; i++) {
 169         if ( fprintf(md5sum_fd, "%02x", md5sum[i]) < 0 ) md5sum_write_error();
 170     }
 171     if ( fprintf(md5sum_fd, " frame%08d\n", framenum) < 0 )
 172         md5sum_write_error();
 173
 174     framenum++;
 175 }
 176
 177 /* ------------------------------------------------------------------------- */
 178
 179 static int draw_frame(uint8_t *src[])
 180 {
 181     mp_msg(MSGT_VO, MSGL_V, "%s: draw_frame() is called!\n", info.short_name);
 182     return -1;
 183 }
 184
 185 /* ------------------------------------------------------------------------- */
 186
 187 static uint32_t draw_image(mp_image_t *mpi)
 188 {
 189     unsigned char md5sum[16];
 190     uint32_t w = mpi->w;
 191     uint32_t h = mpi->h;
 192     uint8_t *rgbimage = mpi->planes[0];
 193     uint8_t *planeY = mpi->planes[0];
 194     uint8_t *planeU = mpi->planes[1];
 195     uint8_t *planeV = mpi->planes[2];
 196     uint32_t strideY = mpi->stride[0];
 197     uint32_t strideU = mpi->stride[1];
 198     uint32_t strideV = mpi->stride[2];
 199
 200     uint8_t md5_context_memory[av_md5_size];
 201     struct AVMD5 *md5_context = (struct AVMD5*) md5_context_memory;
 202     unsigned int i;
 203
 204     if (mpi->flags & MP_IMGFLAG_PLANAR) { /* Planar */
 205         if (mpi->flags & MP_IMGFLAG_YUV) { /* Planar YUV */
 206             av_md5_init(md5_context);
 207             for (i=0; i<h; i++) {
 208                 av_md5_update(md5_context, planeY + i * strideY, w);
 209             }
 210             w = w / 2;
 211             h = h / 2;
 212             for (i=0; i<h; i++) {
 213                 av_md5_update(md5_context, planeU + i * strideU, w);
 214             }
 215             for (i=0; i<h; i++) {
 216                 av_md5_update(md5_context, planeV + i * strideV, w);
 217             }
 218             av_md5_final(md5_context, md5sum);
 219             md5sum_output_sum(md5sum);
 220             return VO_TRUE;
 221         } else { /* Planar RGB */
 222             return VO_FALSE;
 223         }
 224     } else { /* Packed */
 225         if (mpi->flags & MP_IMGFLAG_YUV) { /* Packed YUV */
 226
 227             return VO_FALSE;
 228         } else { /* Packed RGB */
 229             av_md5_sum(md5sum, rgbimage, mpi->w * (mpi->bpp >> 3) * mpi->h);
 230             md5sum_output_sum(md5sum);
 231             return VO_TRUE;
 232         }
 233     }
 234
 235     return VO_FALSE;
 236 }
 237
 238 /* ------------------------------------------------------------------------- */
 239
 240 static int draw_slice(uint8_t *src[], int stride[], int w, int h,
 241                            int x, int y)
 242 {
 243     return 0;
 244 }
 245
 246 /* ------------------------------------------------------------------------- */
 247
 248 static int query_format(uint32_t format)
 249 {
 250     switch (format) {
 251         case IMGFMT_RGB24:
 252         case IMGFMT_YV12:
 253             return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW;
 254         default:
 255             return 0;
 256     }
 257 }
 258
 259 /* ------------------------------------------------------------------------- */
 260
 261 static int control(uint32_t request, void *data)
 262 {
 263     switch (request) {
 264         case VOCTRL_QUERY_FORMAT:
 265             return query_format(*((uint32_t*)data));
 266         case VOCTRL_DRAW_IMAGE:
 267             return draw_image(data);
 268     }
 269     return VO_NOTIMPL;
 270 }
 271
 272 /* ------------------------------------------------------------------------- */
 273
 274 static void uninit(void)
 275 {
 276     free(md5sum_outfile);
 277     md5sum_outfile = NULL;
 278     if (md5sum_fd) fclose(md5sum_fd);
 279 }
 280
 281 /* ------------------------------------------------------------------------- */
 282
 283 static void check_events(void)
 284 {
 285 }
 286
 287 /* ------------------------------------------------------------------------- */
 288
 289 static void draw_osd(void)
 290 {
 291 }
 292
 293 /* ------------------------------------------------------------------------- */
 294
 295 static void flip_page (void)
 296 {
 297 }