Mercurial > mplayer.hg
view libvo/vo_mng.c @ 34697:ac6b38cd0d45
Rename sub window video window.
It was a bad idea to name the video window "sub window" at the time
the GUI was written. The term "sub window" does make sense from the
programmer's point of view, but it doesn't make any sense at all from
the user's point of view, because the sub window simply is the window
where the video will be displayed.
Moreover, since the term "sub" is generally short for "subtitles",
the renaming makes the code much easier to understand.
author | ib |
---|---|
date | Sat, 03 Mar 2012 16:45:15 +0000 |
parents | cc3071a7c057 |
children | 5d3f93051de9 |
line wrap: on
line source
/* * MPlayer output to MNG file * * Copyright (C) 2011 Stefan Schuermans <stefan blinkenarea org> * * This file is part of MPlayer. * * MPlayer is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * MPlayer is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with MPlayer; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include <stdlib.h> #include <string.h> #include <unistd.h> #include <fcntl.h> #include <errno.h> #include <sys/stat.h> #include <sys/types.h> #include <zlib.h> #define MNG_INCLUDE_WRITE_PROCS #define MNG_ACCESS_CHUNKS #define MNG_SUPPORT_READ #define MNG_SUPPORT_DISPLAY #define MNG_SUPPORT_WRITE #include <libmng.h> #include "video_out.h" #include "video_out_internal.h" #include "mp_msg.h" #include "subopt-helper.h" #define VOMNG_DEFAULT_DELAY_MS (100) /* default delay of a frame */ static vo_info_t info = { .name = "MNG file", .short_name = "mng", .author = "Stefan Schuermans <stefan blinkenarea org>" }; LIBVO_EXTERN(mng) /* a frame to be written to the MNG file */ struct vomng_frame { mng_ptr data; /**< deflate compressed data, malloc-ed */ mng_uint32 len; /**< length of compressed data */ unsigned int time_ms; /**< timestamp of frame (in ms) */ struct vomng_frame *next; /**< next frame */ }; /* properties of MNG output */ struct vomng_properties { char *out_file_name; /**< name of output file, malloc-ed */ unsigned int width, height; /**< dimensions */ unsigned char *canvas; /**< canvas for frame, canvas := row ... row, row := filter_id pix ... pix, pix := red green blue */ struct vomng_frame *frame_first; /**< list of frames */ struct vomng_frame *frame_last; int is_init; /**< if initialized */ }; /* private data of MNG vo module */ static struct vomng_properties vomng; /** * @brief libmng callback: allocate memory * @param[in] size size of requested memory block * @return pointer to memory block, which is initialized to zero */ static mng_ptr vomng_alloc(mng_size_t size) { return calloc(1, size); } /** * @brief libmng callback: free memory * @param[in] pointer to memory block * @param[in] size size of requested memory block */ static void vomng_free(mng_ptr ptr, mng_size_t size) { free(ptr); } /** * @brief libmng callback: open stream * @param[in] mng libmng handle * @return if stream could be opened */ static mng_bool vomng_openstream(mng_handle mng) { return MNG_TRUE; /* stream is always open wen we get here, tell libmng that everything is okay */ } /** * @brief libmng callback: stream should be closed * @param[in] mng libmng handle * @return if stream could be closed */ static mng_bool vomng_closestream(mng_handle mng) { return MNG_TRUE; /* stream will be closed later, tell libmng that everything is okay */ } /** * @brief libmng callback: write libmng data to the open stream * @param[in] mng libmng handle * @param[in] *buf pointer to data to write * @param[in] size size of data to write * @param[out] *written size of data written * @return if data was written successfully */ static mng_bool vomng_writedata(mng_handle mng, mng_ptr buf, mng_uint32 size, mng_uint32 *written) { FILE *file = mng_get_userdata(mng); *written = fwrite(buf, 1, size, file); /* according to the example in libmng documentation, true is always returned here, short writes can be detected by libmng via *written */ return MNG_TRUE; } /** * @brief compress frame data * @param[in] width width of canvas * @param[in] height height of canvas * @param[in] *canvas data on canvas (including MNG filter IDs) * @param[out] *out_ptr pointer to compressed data, malloc-ed * @param[out] *out_len length of compressed data */ static void vomng_canvas_to_compressed(unsigned int width, unsigned int height, const unsigned char *canvas, mng_ptr *out_ptr, mng_uint32 *out_len) { mng_uint32 raw_len; unsigned char *ptr; unsigned long len; /* default: no output */ *out_ptr = NULL; *out_len = 0; /* raw_len := length of input data - it will be significantly shorter than 32 bit - the "1 +" is needed because each row starts with the filter ID */ raw_len = height * (1 + width * 3); /* compress data - compress2 output size will be smaller than raw_len * 1.001 + 12 (see man page), so calculate the next larger integer value in len and allocate abuffer of this size - len will still contain a value shorter than 32 bit */ len = raw_len + (raw_len + 999) / 1000 + 12; ptr = malloc(len); if (!ptr) return; compress2(ptr, &len, canvas, raw_len, Z_BEST_COMPRESSION); /* return allocated compressed data - we have to convert the output length to a shorter data type as libmng does not accept an unsigned long as length - convert here, because we can see here that the conversion is safe - see comments about raw_len and len above - compress2 never increases value of len */ *out_ptr = ptr; *out_len = len; } /** * @brief write frame to MNG file * @param[in] *frame the frame to write to MNG file * @param[in] mng libmng handle * @param[in] width width of canvas * @param[in] height height of canvas * @param[in] first_frame if the frame is the first one in the file * @return 0 on success, 1 on error */ static int vomng_write_frame(struct vomng_frame *frame, mng_handle mng, unsigned int width, unsigned int height, int first_frame) { unsigned int delay_ms; /* determine delay */ if (frame->next) delay_ms = frame->next->time_ms - frame->time_ms; else delay_ms = VOMNG_DEFAULT_DELAY_MS; /* default delay for last frame */ /* write frame headers to MNG file */ if (mng_putchunk_seek(mng, 0, MNG_NULL)) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing SEEK chunk failed\n"); return 1; } if (mng_putchunk_fram(mng, MNG_FALSE, /* keep canvas if not 1st frame */ first_frame ? MNG_FRAMINGMODE_1 : MNG_FRAMINGMODE_NOCHANGE, 0, MNG_NULL, /* no frame name */ MNG_CHANGEDELAY_DEFAULT, /* change only delay */ MNG_CHANGETIMOUT_NO, MNG_CHANGECLIPPING_NO, MNG_CHANGESYNCID_NO, delay_ms, /* new delay */ 0, /* no new timeout */ 0, 0, 0, 0, 0, /* no new boundary */ 0, 0)) { /* no count, no IDs */ mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing FRAM chunk failed\n"); return 1; } if (mng_putchunk_defi(mng, 0, /* no ID */ MNG_DONOTSHOW_VISIBLE, MNG_ABSTRACT, MNG_TRUE, 0, 0, /* top left location */ MNG_FALSE, 0, 0, 0, 0)) { /* no clipping */ mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing DEFI chunk failed\n"); return 1; } if (mng_putchunk_ihdr(mng, width, height, /* dimensions */ 8, MNG_COLORTYPE_RGB, /* RBG */ MNG_COMPRESSION_DEFLATE, MNG_FILTER_ADAPTIVE, MNG_INTERLACE_NONE)) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing IHDR chunk failed\n"); return 1; } /* write frame data */ if (mng_putchunk_idat(mng, frame->len, frame->data)) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing IDAT chunk failed\n"); return 1; } /* write frame footers to MNG file */ if (mng_putchunk_iend(mng)) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing IEND chunk failed\n"); return 1; } return 0; } /** * @brief write buffered frames to MNG file * @return 0 on success, 1 on error */ static int vomng_write_file(void) { FILE *file; mng_handle mng; struct vomng_frame *frame; unsigned int frames, duration_ms; int first; /* refuse to create empty MNG file */ if (!vomng.frame_first || !vomng.frame_last) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: not creating empty file\n"); return 1; } /* create output file */ file = fopen(vomng.out_file_name, "wb"); if (!file) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: could not open output file \"%s\": %s\n", vomng.out_file_name, strerror(errno)); return 1; } /* inititalize MNG library */ mng = mng_initialize(file, vomng_alloc, vomng_free, MNG_NULL); if (!mng) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: could not initialize libmng\n"); fclose(file); return 1; } if (mng_setcb_openstream (mng, vomng_openstream ) || mng_setcb_closestream(mng, vomng_closestream) || mng_setcb_writedata (mng, vomng_writedata )) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: cannot set callbacks for libmng\n"); mng_cleanup(&mng); fclose(file); return 1; } /* create new MNG image in memory */ if (mng_create(mng)) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: cannot create MNG image in memory\n"); mng_cleanup(&mng); fclose(file); return 1; } /* determine number of frames and total duration */ frames = 0; for (frame = vomng.frame_first; frame; frame = frame->next) frames++; duration_ms = vomng.frame_last->time_ms - vomng.frame_first->time_ms; /* write MNG header chunks */ if (mng_putchunk_mhdr(mng, vomng.width, /* dimensions */ vomng.height, 1000, 0, /* ticks per second, layer */ frames, /* number of frames */ duration_ms, /* total duration */ MNG_SIMPLICITY_VALID | MNG_SIMPLICITY_SIMPLEFEATURES | MNG_SIMPLICITY_COMPLEXFEATURES) || mng_putchunk_save(mng, MNG_TRUE, 0, 0) || /* empty save chunk */ mng_putchunk_term(mng, MNG_TERMACTION_CLEAR, /* show last frame forever */ MNG_ITERACTION_CLEAR, 0, 0)) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing MHDR/SAVE/TERM chunks failed\n"); mng_write(mng); /* write out buffered chunks before cleanup */ mng_cleanup(&mng); fclose(file); return 1; } /* write frames */ first = 1; for (frame = vomng.frame_first; frame; frame = frame->next) { if (vomng_write_frame(frame, mng, vomng.width, vomng.height, first)) break; first = 0; } if (frame) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing frames failed\n"); mng_write(mng); /* write out buffered chunks before cleanup */ mng_cleanup(&mng); fclose(file); return 1; } /* write MNG end chunk */ if (mng_putchunk_mend(mng)) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing end chunk failed\n"); mng_write(mng); /* write out buffered chunks before cleanup */ mng_cleanup(&mng); fclose(file); return 1; } /* finish and cleanup */ mng_write(mng); /* write out buffered chunks before cleanup */ mng_cleanup(&mng); fclose(file); return 0; } /** * @brief close all files and free all memory of MNG vo module */ static void vomng_prop_reset(void) { struct vomng_frame *frame, *next; /* we are initialized properly */ if (vomng.is_init) { /* write buffered frames to MNG file */ if (vomng_write_file()) mp_msg(MSGT_VO, MSGL_ERR, "vomng: writing output file failed\n"); } /* reset state */ vomng.is_init = 0; if (vomng.frame_first) { frame = vomng.frame_first; while (frame) { next = frame->next; free(frame->data); free(frame); frame = next; } vomng.frame_first = NULL; vomng.frame_last = NULL; } free(vomng.canvas); vomng.canvas = NULL; vomng.width = 0; vomng.height = 0; } /** * @brief close files, free memory and delete private data of MNG von module */ static void vomng_prop_cleanup(void) { vomng_prop_reset(); free(vomng.out_file_name); } /** * @brief configure MNG vo module * @param[in] width video width * @param[in] height video height * @param[in] d_width (unused) * @param[in] d_height (unused) * @param[in] flags (unused) * @param[in] title (unused) * @param[in] format video frame format * @return 0 on success, 1 on error */ static int config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format) { uint32_t row_stride, y; /* reset state */ vomng_prop_reset(); /* check format */ if (format != IMGFMT_RGB24) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: config with invalid format (!= IMGFMT_RGB24)\n"); return 1; } /* allocate canvas */ vomng.width = width; vomng.height = height; row_stride = 1 + width * 3; /* rows contain filter IDs */ vomng.canvas = calloc(height * row_stride, 1); if (!vomng.canvas) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: out of memory\n"); return 1; } /* fill in filter IDs for rows */ for (y = 0; y < height; y++) *(vomng.canvas + row_stride * y) = MNG_FILTER_NONE; /* we are initialized */ vomng.is_init = 1; return 0; } /** * @brief draw on screen display (unsupported for MNG vo module) */ static void draw_osd(void) { } /** * @brief display data currently on canvas */ static void flip_page(void) { unsigned int last_ms; struct vomng_frame *frame; /* get time of last frame in ms (intensive testing showed that the time obtained from vo_pts is the time of the previous frame) */ last_ms = (unsigned int)(vo_pts / 90.0 + 0.5); /* set time of last frame */ if (vomng.frame_last) vomng.frame_last->time_ms = last_ms; /* create new frame */ frame = calloc(1, sizeof(*frame)); if (!frame) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: out of memory\n"); return; } /* time of frame is not yet known (see comment about vo_pts about 20 lines above), approximate time using time of last frame and the default frame delay */ frame->time_ms = last_ms + VOMNG_DEFAULT_DELAY_MS; frame->next = NULL; /* compress canvas data */ vomng_canvas_to_compressed(vomng.width, vomng.height, vomng.canvas, &frame->data, &frame->len); if (!frame->data) { mp_msg(MSGT_VO, MSGL_ERR, "vomng: compressing frame failed\n"); free(frame); return; } /* add frame to list */ if (!vomng.frame_first || !vomng.frame_last) { vomng.frame_first = frame; vomng.frame_last = frame; } else { vomng.frame_last->next = frame; vomng.frame_last = frame; } } /** * @brief put frame data onto canvas (not supported) * @return always 1 to indicate error */ static int draw_frame(uint8_t *src[]) { /* draw_frame() not supported * VFCAP_ACCEPT_STRIDE is set for format * so draw_slice() will be called instead of this function */ return 1; } /** * @brief deinitialize MNG vo module */ static void uninit(void) { vomng_prop_cleanup(); } /** * @brief deal with events (not supported) */ static void check_events(void) { } /** * @brief put a slice of frame data onto canvas * @param[in] srcimg pointer to data * @param[in] stride line stride in data * @param[in] wf frame slice width * @param[in] hf frame slice height * @param[in] xf leftmost x coordinate of frame slice * @param[in] yf topmost y coordinate of frame slice * @return always 0 to indicate success */ static int draw_slice(uint8_t *srcimg[], int stride[], int wf, int hf, int xf, int yf) { uint8_t *line_ptr; int line_len, row_stride, y; /* put pixel data from slice to canvas */ line_ptr = srcimg[0]; line_len = stride[0]; row_stride = 1 + vomng.width * 3; /* rows contain filter IDs */ for (y = 0; y < hf; y++) memcpy(vomng.canvas + (yf + y) * row_stride + 1 + xf * 3, line_ptr + y * line_len, wf * 3); return 0; } /** list of suboptions */ static const opt_t subopts[] = { {"output", OPT_ARG_MSTRZ, &vomng.out_file_name, NULL}, {NULL, 0, NULL, NULL} }; /** * @brief pre-initialize MNG vo module * @param[in] *arg arguments passed to MNG vo module (output file name) * @return 0 on success, 1 on error */ static int preinit(const char *arg) { if (subopt_parse(arg, subopts)) { mp_msg(MSGT_VO, MSGL_ERR, "\n-vo mng command line help:\n" "Example: mplayer -vo mng:output=file.mng\n" "\nOptions:\n" " output=<filename>\n" " Specify the output file. The default is out.mng.\n" "\n"); vomng_prop_cleanup(); return 1; } if (!vomng.out_file_name) vomng.out_file_name = strdup("out.mng"); return 0; } /** * @brief get supported formats * @param[in] format format to check support for * @return acceptance flags */ static int query_format(uint32_t format) { if (format == IMGFMT_RGB24) return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_ACCEPT_STRIDE; return 0; } /** * @brief handle control stuff * @param[in] request control request * @param[in] *data data (dependent on control request) * @return response to control request */ static int control(uint32_t request, void *data) { switch (request) { case VOCTRL_QUERY_FORMAT: return query_format(*((uint32_t *)data)); } return VO_NOTIMPL; }