2010-01-30 16:57:40 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2008-02-22 09:09:46 +00:00
|
|
|
#ifndef MPLAYER_MP_IMAGE_H
|
|
|
|
#define MPLAYER_MP_IMAGE_H
|
2002-01-16 00:14:59 +00:00
|
|
|
|
2012-12-11 23:43:36 +00:00
|
|
|
#include <stdbool.h>
|
2008-03-06 08:34:50 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2012-10-27 15:59:16 +00:00
|
|
|
#include <inttypes.h>
|
2013-12-18 16:12:21 +00:00
|
|
|
#include "common/common.h"
|
2013-12-17 01:39:45 +00:00
|
|
|
#include "common/msg.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "csputils.h"
|
2012-12-31 00:58:25 +00:00
|
|
|
#include "video/img_format.h"
|
2008-03-06 08:34:50 +00:00
|
|
|
|
mp_image: simplify image allocation
mp_image_alloc_planes() allocated images with minimal stride, even if
the resulting stride was unaligned. It was the responsibility of
vf_get_image() to set an image's width to something larger than
required to get an aligned stride, and then crop it. Always allocate
with aligned strides instead.
Get rid of IMGFMT_IF09 special handling. This format is not used
anymore. (IF09 has 4x4 chroma sub-sampling, and that is what it was
mainly used for - this is still supported.) Get rid of swapped chroma
plane allocation. This is not used anywhere, and VOs like vo_xv,
vo_direct3d and vo_sdl do their own swapping.
Always round chroma width/height up instead of down. Consider 4:2:0 and
an uneven image size. For luma, the size was left uneven, and the chroma
size was rounded down. This doesn't make sense, because chroma would be
missing for the bottom/right border.
Remove mp_image_new_empty() and mp_image_alloc_planes(), they were not
used anymore, except in draw_bmp.c. (It's still allowed to setup
mp_images manually, you just can't allocate image data with them
anymore - this is also done in draw_bmp.c.)
2012-12-19 11:04:32 +00:00
|
|
|
#define MP_PALETTE_SIZE (256 * 4)
|
2002-08-02 22:55:54 +00:00
|
|
|
|
2003-08-18 14:49:06 +00:00
|
|
|
#define MP_IMGFIELD_ORDERED 0x01
|
|
|
|
#define MP_IMGFIELD_TOP_FIRST 0x02
|
|
|
|
#define MP_IMGFIELD_REPEAT_FIRST 0x04
|
|
|
|
#define MP_IMGFIELD_TOP 0x08
|
|
|
|
#define MP_IMGFIELD_BOTTOM 0x10
|
2003-12-22 17:26:19 +00:00
|
|
|
#define MP_IMGFIELD_INTERLACED 0x20
|
2003-08-03 12:09:58 +00:00
|
|
|
|
2013-08-24 17:37:34 +00:00
|
|
|
// Describes image parameters that usually stay constant.
|
|
|
|
// New fields can be added in the future. Code changing the parameters should
|
|
|
|
// usually copy the whole struct, so that fields added later will be preserved.
|
2013-06-07 23:35:44 +00:00
|
|
|
struct mp_image_params {
|
|
|
|
enum mp_imgfmt imgfmt; // pixel format
|
|
|
|
int w, h; // image dimensions
|
|
|
|
int d_w, d_h; // define display aspect ratio (never 0/0)
|
|
|
|
enum mp_csp colorspace;
|
|
|
|
enum mp_csp_levels colorlevels;
|
2014-03-26 00:46:38 +00:00
|
|
|
enum mp_csp_prim primaries;
|
vo_opengl: handle chroma location
Use the video decoder chroma location flags and render chroma locations
other than centered. Until now, we've always used the intuitive and
obvious centered chroma location, but H.264 uses something else.
FFmpeg provides a small overview in libavcodec/avcodec.h:
-----------
/**
* X X 3 4 X X are luma samples,
* 1 2 1-6 are possible chroma positions
* X X 5 6 X 0 is undefined/unknown position
*/
enum AVChromaLocation{
AVCHROMA_LOC_UNSPECIFIED = 0,
AVCHROMA_LOC_LEFT = 1, ///< mpeg2/4, h264 default
AVCHROMA_LOC_CENTER = 2, ///< mpeg1, jpeg, h263
AVCHROMA_LOC_TOPLEFT = 3, ///< DV
AVCHROMA_LOC_TOP = 4,
AVCHROMA_LOC_BOTTOMLEFT = 5,
AVCHROMA_LOC_BOTTOM = 6,
AVCHROMA_LOC_NB , ///< Not part of ABI
};
-----------
The visual difference is literally minimal, but since videophiles
apparently consider this detail as quality mark of a video renderer,
support it anyway. We don't bother with chroma locations other than
centered and left, though.
Not sure about correctness, but it's probably ok.
2013-06-08 00:15:24 +00:00
|
|
|
enum mp_chroma_location chroma_location;
|
2013-08-24 17:37:34 +00:00
|
|
|
// The image should be converted to these levels. Unlike colorlevels, it
|
|
|
|
// does not describe the current state of the image. (Somewhat similar to
|
|
|
|
// d_w/d_h vs. w/h.)
|
|
|
|
enum mp_csp_levels outputlevels;
|
2014-04-20 19:28:09 +00:00
|
|
|
// The image should be rotated clockwise (0-359 degrees).
|
|
|
|
int rotate;
|
2014-08-30 21:24:46 +00:00
|
|
|
enum mp_stereo3d_mode stereo_in; // image is encoded with this mode
|
|
|
|
enum mp_stereo3d_mode stereo_out; // should be displayed with this mode
|
2013-06-07 23:35:44 +00:00
|
|
|
};
|
|
|
|
|
2012-12-11 23:43:36 +00:00
|
|
|
/* Memory management:
|
|
|
|
* - mp_image is a light-weight reference to the actual image data (pixels).
|
|
|
|
* The actual image data is reference counted and can outlive mp_image
|
|
|
|
* allocations. mp_image references can be created with mp_image_new_ref()
|
|
|
|
* and free'd with talloc_free() (the helpers mp_image_setrefp() and
|
|
|
|
* mp_image_unrefp() can also be used). The actual image data is free'd when
|
|
|
|
* the last mp_image reference to it is free'd.
|
|
|
|
* - Each mp_image has a clear owner. The owner can do anything with it, such
|
|
|
|
* as changing mp_image fields. Instead of making ownership ambiguous by
|
|
|
|
* sharing a mp_image reference, new references should be created.
|
|
|
|
* - Write access to the actual image data is allowed only after calling
|
|
|
|
* mp_image_make_writeable(), or if mp_image_is_writeable() returns true.
|
|
|
|
* Conceptually, images can be changed by their owner only, and copy-on-write
|
|
|
|
* is used to ensure that other references do not see any changes to the
|
|
|
|
* image data. mp_image_make_writeable() will do that copy if required.
|
|
|
|
*/
|
2008-04-24 02:49:44 +00:00
|
|
|
typedef struct mp_image {
|
2013-07-18 11:49:28 +00:00
|
|
|
unsigned int flags; // same as fmt.flags
|
2012-12-31 00:58:25 +00:00
|
|
|
|
2014-04-20 19:27:45 +00:00
|
|
|
struct mp_image_params params;
|
|
|
|
|
|
|
|
// fields redundant to params.imgfmt, for convenience or compatibility
|
|
|
|
struct mp_imgfmt_desc fmt;
|
2013-06-07 23:35:44 +00:00
|
|
|
enum mp_imgfmt imgfmt;
|
2012-12-31 00:58:25 +00:00
|
|
|
int num_planes;
|
|
|
|
int chroma_x_shift; // horizontal
|
|
|
|
int chroma_y_shift; // vertical
|
|
|
|
|
2012-02-24 14:25:22 +00:00
|
|
|
int w,h; // visible dimensions
|
2012-10-27 15:59:16 +00:00
|
|
|
uint8_t *planes[MP_MAX_PLANES];
|
2005-02-24 16:52:18 +00:00
|
|
|
int stride[MP_MAX_PLANES];
|
2012-12-31 00:58:25 +00:00
|
|
|
|
2002-10-29 11:26:26 +00:00
|
|
|
int pict_type; // 0->unknown, 1->I, 2->P, 3->B
|
2003-08-18 14:49:06 +00:00
|
|
|
int fields;
|
2012-12-31 00:58:25 +00:00
|
|
|
|
|
|
|
/* redundant */
|
2002-06-23 20:42:19 +00:00
|
|
|
int chroma_width;
|
|
|
|
int chroma_height;
|
2012-12-31 00:58:25 +00:00
|
|
|
int plane_w[MP_MAX_PLANES];
|
|
|
|
int plane_h[MP_MAX_PLANES];
|
|
|
|
|
video/filter: change filter API, use refcounting, remove filter DR
Change the entire filter API to use reference counted images instead
of vf_get_image().
Remove filter "direct rendering". This was useful for vf_expand and (in
rare cases) vf_sub: DR allowed these filters to pass a cropped image to
the filters before them. Then, on filtering, the image was "uncropped",
so that black bars could be added around the image without copying. This
means that in some cases, vf_expand will be slower (-vf gradfun,expand
for example).
Note that another form of DR used for in-place filters has been replaced
by simpler logic. Instead of trying to do DR, filters can check if the
image is writeable (with mp_image_is_writeable()), and do true in-place
if that's the case. This affects filters like vf_gradfun and vf_sub.
Everything has to support strides now. If something doesn't, making a
copy of the image data is required.
2012-11-05 13:25:04 +00:00
|
|
|
/* only inside filter chain */
|
|
|
|
double pts;
|
2012-12-11 23:43:36 +00:00
|
|
|
/* memory management */
|
|
|
|
struct m_refcount *refcount;
|
2012-12-12 22:55:41 +00:00
|
|
|
/* for private use */
|
2002-07-20 16:26:49 +00:00
|
|
|
void* priv;
|
2002-01-16 00:14:59 +00:00
|
|
|
} mp_image_t;
|
|
|
|
|
2014-03-17 17:19:57 +00:00
|
|
|
struct mp_image *mp_image_alloc(int fmt, int w, int h);
|
2012-12-11 23:43:36 +00:00
|
|
|
void mp_image_copy(struct mp_image *dmpi, struct mp_image *mpi);
|
|
|
|
void mp_image_copy_attributes(struct mp_image *dmpi, struct mp_image *mpi);
|
|
|
|
struct mp_image *mp_image_new_copy(struct mp_image *img);
|
|
|
|
struct mp_image *mp_image_new_ref(struct mp_image *img);
|
|
|
|
bool mp_image_is_writeable(struct mp_image *img);
|
video: introduce failure path for image allocations
Until now, failure to allocate image data resulted in a crash (i.e.
abort() was called). This was intentional, because it's pretty silly to
degrade playback, and in almost all situations, the OOM will probably
kill you anyway. (And then there's the standard Linux overcommit
behavior, which also will kill you at some point.)
But I changed my opinion, so here we go. This change does not affect
_all_ memory allocations, just image data. Now in most failure cases,
the output will just be skipped. For video filters, this coincidentally
means that failure is treated as EOF (because the playback core assumes
EOF if nothing comes out of the video filter chain). In other
situations, output might be in some way degraded, like skipping frames,
not scaling OSD, and such.
Functions whose return values changed semantics:
mp_image_alloc
mp_image_new_copy
mp_image_new_ref
mp_image_make_writeable
mp_image_setrefp
mp_image_to_av_frame_and_unref
mp_image_from_av_frame
mp_image_new_external_ref
mp_image_new_custom_ref
mp_image_pool_make_writeable
mp_image_pool_get
mp_image_pool_new_copy
mp_vdpau_mixed_frame_create
vf_alloc_out_image
vf_make_out_image_writeable
glGetWindowScreenshot
2014-06-17 20:43:43 +00:00
|
|
|
bool mp_image_make_writeable(struct mp_image *img);
|
2012-12-11 23:43:36 +00:00
|
|
|
void mp_image_setrefp(struct mp_image **p_img, struct mp_image *new_value);
|
|
|
|
void mp_image_unrefp(struct mp_image **p_img);
|
|
|
|
|
2012-12-26 20:13:58 +00:00
|
|
|
void mp_image_clear(struct mp_image *mpi, int x0, int y0, int x1, int y1);
|
2012-12-25 21:29:49 +00:00
|
|
|
void mp_image_crop(struct mp_image *img, int x0, int y0, int x1, int y1);
|
|
|
|
void mp_image_crop_rc(struct mp_image *img, struct mp_rect rc);
|
2013-03-01 10:28:59 +00:00
|
|
|
void mp_image_vflip(struct mp_image *img);
|
2012-12-25 21:29:49 +00:00
|
|
|
|
2012-11-10 01:02:24 +00:00
|
|
|
void mp_image_set_size(struct mp_image *mpi, int w, int h);
|
|
|
|
|
2014-03-17 17:19:57 +00:00
|
|
|
void mp_image_setfmt(mp_image_t* mpi, int out_fmt);
|
2012-12-11 23:43:36 +00:00
|
|
|
void mp_image_steal_data(struct mp_image *dst, struct mp_image *src);
|
|
|
|
|
|
|
|
struct mp_image *mp_image_new_custom_ref(struct mp_image *img, void *arg,
|
|
|
|
void (*free)(void *arg));
|
2002-04-20 22:24:19 +00:00
|
|
|
|
2012-12-11 23:43:36 +00:00
|
|
|
struct mp_image *mp_image_new_external_ref(struct mp_image *img, void *arg,
|
|
|
|
void (*ref)(void *arg),
|
|
|
|
void (*unref)(void *arg),
|
2013-03-09 19:21:12 +00:00
|
|
|
bool (*is_unique)(void *arg),
|
|
|
|
void (*free)(void *arg));
|
2007-08-04 22:12:49 +00:00
|
|
|
|
2013-06-29 22:27:50 +00:00
|
|
|
void mp_image_params_guess_csp(struct mp_image_params *params);
|
|
|
|
|
2014-11-12 18:19:16 +00:00
|
|
|
char *mp_image_params_to_str_buf(char *b, size_t bs,
|
|
|
|
const struct mp_image_params *p);
|
2014-11-12 18:30:34 +00:00
|
|
|
#define mp_image_params_to_str(p) mp_image_params_to_str_buf((char[80]){0}, 80, p)
|
2014-11-12 18:19:16 +00:00
|
|
|
|
2014-06-17 20:44:13 +00:00
|
|
|
bool mp_image_params_valid(const struct mp_image_params *p);
|
2014-06-17 21:30:16 +00:00
|
|
|
bool mp_image_params_equal(const struct mp_image_params *p1,
|
|
|
|
const struct mp_image_params *p2);
|
2013-07-18 11:17:56 +00:00
|
|
|
|
2013-07-18 11:42:57 +00:00
|
|
|
void mp_image_set_params(struct mp_image *image,
|
|
|
|
const struct mp_image_params *params);
|
|
|
|
|
2013-11-03 22:55:16 +00:00
|
|
|
void mp_image_set_attributes(struct mp_image *image,
|
|
|
|
const struct mp_image_params *params);
|
|
|
|
|
2013-03-09 19:21:12 +00:00
|
|
|
struct AVFrame;
|
|
|
|
void mp_image_copy_fields_from_av_frame(struct mp_image *dst,
|
|
|
|
struct AVFrame *src);
|
2013-03-10 18:30:48 +00:00
|
|
|
void mp_image_copy_fields_to_av_frame(struct AVFrame *dst,
|
|
|
|
struct mp_image *src);
|
2013-03-09 19:50:06 +00:00
|
|
|
struct mp_image *mp_image_from_av_frame(struct AVFrame *av_frame);
|
2013-03-10 18:30:48 +00:00
|
|
|
struct AVFrame *mp_image_to_av_frame_and_unref(struct mp_image *img);
|
2013-03-09 19:21:12 +00:00
|
|
|
|
2008-02-22 09:09:46 +00:00
|
|
|
#endif /* MPLAYER_MP_IMAGE_H */
|