eessppeelllloo/veejay
1
0
Fork 0
mirror of https://github.com/game-stop/veejay.git synced 2025-12-18 13:49:58 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
53b51e0deb1eefcfd8cbf579367bee9c21331096
veejay/veejay-current/veejay-client/mjpeg/yuv4mpeg.h
Niels Elburg 4fad025d23 added mjpeg stuff 
git-svn-id: svn://code.dyne.org/veejay/trunk@1234 eb8d1916-c9e9-0310-b8de-cf0c9472ead5
2008-11-30 21:34:51 +00:00

758 lines
29 KiB
C
Raw Blame History

/*
* yuv4mpeg.h: Functions for reading and writing "new" YUV4MPEG2 streams.
*
* Stream format is described at the end of this file.
*
*
* Copyright (C) 2004 Matthew J. Marjanovic <maddog@mir.com>
*
*
* This program 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.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __YUV4MPEG_H__
#define __YUV4MPEG_H__
#include <stdlib.h>
#include <mjpeg_types.h>
#ifndef _WIN32
#include <unistd.h>
#endif
#include <mjpeg_logging.h>
/************************************************************************
* error codes returned by y4m_* functions
************************************************************************/
#define Y4M_OK 0
#define Y4M_ERR_RANGE 1 /* argument or tag value out of range */
#define Y4M_ERR_SYSTEM 2 /* failed system call, check errno */
#define Y4M_ERR_HEADER 3 /* illegal/malformed header */
#define Y4M_ERR_BADTAG 4 /* illegal tag character */
#define Y4M_ERR_MAGIC 5 /* bad header magic */
#define Y4M_ERR_EOF 6 /* end-of-file (clean) */
#define Y4M_ERR_XXTAGS 7 /* too many xtags */
#define Y4M_ERR_BADEOF 8 /* unexpected end-of-file */
#define Y4M_ERR_FEATURE 9 /* stream requires features beyond allowed level */
/* generic 'unknown' value for integer parameters (e.g. interlace, height) */
#define Y4M_UNKNOWN -1
/************************************************************************
* values for the "interlace" parameter [y4m_*_interlace()]
************************************************************************/
#define Y4M_ILACE_NONE 0 /* non-interlaced, progressive frame */
#define Y4M_ILACE_TOP_FIRST 1 /* interlaced, top-field first */
#define Y4M_ILACE_BOTTOM_FIRST 2 /* interlaced, bottom-field first */
#define Y4M_ILACE_MIXED 3 /* mixed, "refer to frame header" */
/************************************************************************
* values for the "chroma" parameter [y4m_*_chroma()]
************************************************************************/
#define Y4M_CHROMA_420JPEG 0 /* 4:2:0, H/V centered, for JPEG/MPEG-1 */
#define Y4M_CHROMA_420MPEG2 1 /* 4:2:0, H cosited, for MPEG-2 */
#define Y4M_CHROMA_420PALDV 2 /* 4:2:0, alternating Cb/Cr, for PAL-DV */
#define Y4M_CHROMA_444 3 /* 4:4:4, no subsampling, phew. */
#define Y4M_CHROMA_422 4 /* 4:2:2, H cosited */
#define Y4M_CHROMA_411 5 /* 4:1:1, H cosited */
#define Y4M_CHROMA_MONO 6 /* luma plane only */
#define Y4M_CHROMA_444ALPHA 7 /* 4:4:4 with an alpha channel */
/************************************************************************
* values for sampling parameters [y4m_*_spatial(), y4m_*_temporal()]
************************************************************************/
#define Y4M_SAMPLING_PROGRESSIVE 0
#define Y4M_SAMPLING_INTERLACED 1
/************************************************************************
* values for "presentation" parameter [y4m_*_presentation()]
************************************************************************/
#define Y4M_PRESENT_TOP_FIRST 0 /* top-field-first */
#define Y4M_PRESENT_TOP_FIRST_RPT 1 /* top-first, repeat top */
#define Y4M_PRESENT_BOTTOM_FIRST 2 /* bottom-field-first */
#define Y4M_PRESENT_BOTTOM_FIRST_RPT 3 /* bottom-first, repeat bottom */
#define Y4M_PRESENT_PROG_SINGLE 4 /* single progressive frame */
#define Y4M_PRESENT_PROG_DOUBLE 5 /* progressive frame, repeat once */
#define Y4M_PRESENT_PROG_TRIPLE 6 /* progressive frame, repeat twice */
#define Y4M_MAX_NUM_PLANES 4
/************************************************************************
* 'ratio' datatype, for rational numbers
* (see 'ratio' functions down below)
************************************************************************/
typedef struct _y4m_ratio {
int n; /* numerator */
int d; /* denominator */
} y4m_ratio_t;
/************************************************************************
* useful standard framerates (as ratios)
************************************************************************/
extern const y4m_ratio_t y4m_fps_UNKNOWN;
extern const y4m_ratio_t y4m_fps_NTSC_FILM; /* 24000/1001 film (in NTSC) */
extern const y4m_ratio_t y4m_fps_FILM; /* 24fps film */
extern const y4m_ratio_t y4m_fps_PAL; /* 25fps PAL */
extern const y4m_ratio_t y4m_fps_NTSC; /* 30000/1001 NTSC */
extern const y4m_ratio_t y4m_fps_30; /* 30fps */
extern const y4m_ratio_t y4m_fps_PAL_FIELD; /* 50fps PAL field rate */
extern const y4m_ratio_t y4m_fps_NTSC_FIELD; /* 60000/1001 NTSC field rate */
extern const y4m_ratio_t y4m_fps_60; /* 60fps */
/************************************************************************
* useful standard sample (pixel) aspect ratios (W:H)
************************************************************************/
extern const y4m_ratio_t y4m_sar_UNKNOWN;
extern const y4m_ratio_t y4m_sar_SQUARE; /* square pixels */
extern const y4m_ratio_t y4m_sar_NTSC_CCIR601; /* 525-line (NTSC) Rec.601 */
extern const y4m_ratio_t y4m_sar_NTSC_16_9; /* 16:9 NTSC/Rec.601 */
extern const y4m_ratio_t y4m_sar_NTSC_SVCD_4_3; /* NTSC SVCD 4:3 */
extern const y4m_ratio_t y4m_sar_NTSC_SVCD_16_9;/* NTSC SVCD 16:9 */
extern const y4m_ratio_t y4m_sar_PAL_CCIR601; /* 625-line (PAL) Rec.601 */
extern const y4m_ratio_t y4m_sar_PAL_16_9; /* 16:9 PAL/Rec.601 */
extern const y4m_ratio_t y4m_sar_PAL_SVCD_4_3; /* PAL SVCD 4:3 */
extern const y4m_ratio_t y4m_sar_PAL_SVCD_16_9; /* PAL SVCD 16:9 */
extern const y4m_ratio_t y4m_sar_SQR_ANA16_9; /* anamorphic 16:9 sampled */
/* from 4:3 with square pixels */
/************************************************************************
* useful standard display aspect ratios (W:H)
************************************************************************/
extern const y4m_ratio_t y4m_dar_UNKNOWN;
extern const y4m_ratio_t y4m_dar_4_3; /* standard TV */
extern const y4m_ratio_t y4m_dar_16_9; /* widescreen TV */
extern const y4m_ratio_t y4m_dar_221_100; /* word-to-your-mother TV */
#define Y4M_MAX_XTAGS 32 /* maximum number of xtags in list */
#define Y4M_MAX_XTAG_SIZE 32 /* max length of an xtag (including 'X') */
typedef struct _y4m_xtag_list y4m_xtag_list_t;
typedef struct _y4m_stream_info y4m_stream_info_t;
typedef struct _y4m_frame_info y4m_frame_info_t;
#ifdef __cplusplus
#define BEGIN_CDECLS extern "C" {
#define END_CDECLS }
#else
#define BEGIN_CDECLS
#define END_CDECLS
#endif
BEGIN_CDECLS
/************************************************************************
* 'ratio' functions
************************************************************************/
/* 'normalize' a ratio (remove common factors) */
void y4m_ratio_reduce(y4m_ratio_t *r);
/* parse "nnn:ddd" into a ratio (returns Y4M_OK or Y4M_ERR_RANGE) */
int y4m_parse_ratio(y4m_ratio_t *r, const char *s);
/* quick test of two ratios for equality (i.e. identical components) */
#define Y4M_RATIO_EQL(a,b) ( ((a).n == (b).n) && ((a).d == (b).d) )
/* quick conversion of a ratio to a double (no divide-by-zero check!) */
#define Y4M_RATIO_DBL(r) ((double)(r).n / (double)(r).d)
/*************************************************************************
*
* Guess the true SAR (sample aspect ratio) from a list of commonly
* encountered values, given the "suggested" display aspect ratio (DAR),
* and the true frame width and height.
*
* Returns y4m_sar_UNKNOWN if no match is found.
*
*************************************************************************/
y4m_ratio_t y4m_guess_sar(int width, int height, y4m_ratio_t dar);
/*************************************************************************
*
* Chroma Subsampling Mode information
*
* x_ratio, y_ratio - subsampling of chroma planes
* x_offset, y_offset - offset of chroma sample grid,
* relative to luma (0,0) sample
*
*************************************************************************/
y4m_ratio_t y4m_chroma_ss_x_ratio(int chroma_mode);
y4m_ratio_t y4m_chroma_ss_y_ratio(int chroma_mode);
#if 0
y4m_ratio_t y4m_chroma_ss_x_offset(int chroma_mode, int field, int plane);
y4m_ratio_t y4m_chroma_ss_y_offset(int chroma_mode, int field, int plane);
#endif
/* Given a string containing a (case-insensitive) chroma-tag keyword,
return appropriate chroma mode (or Y4M_UNKNOWN) */
int y4m_chroma_parse_keyword(const char *s);
/* Given a Y4M_CHROMA_* mode, return appropriate chroma-tag keyword,
or NULL if there is none. */
const char *y4m_chroma_keyword(int chroma_mode);
/* Given a Y4M_CHROMA_* mode, return appropriate chroma mode description,
or NULL if there is none. */
const char *y4m_chroma_description(int chroma_mode);
/************************************************************************
* 'xtag' functions
*
* o Before using an xtag_list (but after the structure/memory has been
* allocated), you must initialize it via y4m_init_xtag_list().
* o After using an xtag_list (but before the structure is released),
* call y4m_fini_xtag_list() to free internal memory.
*
************************************************************************/
/* initialize an xtag_list structure */
void y4m_init_xtag_list(y4m_xtag_list_t *xtags);
/* finalize an xtag_list structure */
void y4m_fini_xtag_list(y4m_xtag_list_t *xtags);
/* make one xtag_list into a copy of another */
void y4m_copy_xtag_list(y4m_xtag_list_t *dest, const y4m_xtag_list_t *src);
/* return number of tags in an xtag_list */
int y4m_xtag_count(const y4m_xtag_list_t *xtags);
/* access n'th tag in an xtag_list */
const char *y4m_xtag_get(const y4m_xtag_list_t *xtags, int n);
/* append a new tag to an xtag_list
returns: Y4M_OK - success
Y4M_ERR_XXTAGS - list is already full */
int y4m_xtag_add(y4m_xtag_list_t *xtags, const char *tag);
/* remove a tag from an xtag_list
returns: Y4M_OK - success
Y4M_ERR_RANGE - n is out of range */
int y4m_xtag_remove(y4m_xtag_list_t *xtags, int n);
/* remove all tags from an xtag_list
returns: Y4M_OK - success */
int y4m_xtag_clearlist(y4m_xtag_list_t *xtags);
/* append copies of tags from src list to dest list
returns: Y4M_OK - success
Y4M_ERR_XXTAGS - operation would overfill dest list */
int y4m_xtag_addlist(y4m_xtag_list_t *dest, const y4m_xtag_list_t *src);
/************************************************************************
* '*_info' functions
*
* o Before using a *_info structure (but after the structure/memory has
* been allocated), you must initialize it via y4m_init_*_info().
* o After using a *_info structure (but before the structure is released),
* call y4m_fini_*_info() to free internal memory.
* o Use the 'set' and 'get' accessors to modify or access the fields in
* the structures; don't touch the structure directly. (Ok, so there
* is no really convenient C syntax to prevent you from doing this,
* but we are all responsible programmers here, so just don't do it!)
*
************************************************************************/
/* initialize a stream_info structure */
void y4m_init_stream_info(y4m_stream_info_t *i);
/* finalize a stream_info structure */
void y4m_fini_stream_info(y4m_stream_info_t *i);
/* reset stream_info back to default/unknown values */
void y4m_clear_stream_info(y4m_stream_info_t *info);
/* make one stream_info into a copy of another */
void y4m_copy_stream_info(y4m_stream_info_t *dest,
const y4m_stream_info_t *src);
/* access or set stream_info fields */
/* level 0 */
int y4m_si_get_width(const y4m_stream_info_t *si);
int y4m_si_get_height(const y4m_stream_info_t *si);
int y4m_si_get_interlace(const y4m_stream_info_t *si);
y4m_ratio_t y4m_si_get_framerate(const y4m_stream_info_t *si);
y4m_ratio_t y4m_si_get_sampleaspect(const y4m_stream_info_t *si);
void y4m_si_set_width(y4m_stream_info_t *si, int width);
void y4m_si_set_height(y4m_stream_info_t *si, int height);
void y4m_si_set_interlace(y4m_stream_info_t *si, int interlace);
void y4m_si_set_framerate(y4m_stream_info_t *si, y4m_ratio_t framerate);
void y4m_si_set_sampleaspect(y4m_stream_info_t *si, y4m_ratio_t sar);
/* level 1 */
void y4m_si_set_chroma(y4m_stream_info_t *si, int chroma_mode);
int y4m_si_get_chroma(const y4m_stream_info_t *si);
/* derived quantities (no setter) */
/* level 0 */
int y4m_si_get_framelength(const y4m_stream_info_t *si);
/* level 1 */
int y4m_si_get_plane_count(const y4m_stream_info_t *si);
int y4m_si_get_plane_width(const y4m_stream_info_t *si, int plane);
int y4m_si_get_plane_height(const y4m_stream_info_t *si, int plane);
int y4m_si_get_plane_length(const y4m_stream_info_t *si, int plane);
/* access stream_info xtag_list */
y4m_xtag_list_t *y4m_si_xtags(y4m_stream_info_t *si);
/* initialize a frame_info structure */
void y4m_init_frame_info(y4m_frame_info_t *i);
/* finalize a frame_info structure */
void y4m_fini_frame_info(y4m_frame_info_t *i);
/* reset frame_info back to default/unknown values */
void y4m_clear_frame_info(y4m_frame_info_t *info);
/* make one frame_info into a copy of another */
void y4m_copy_frame_info(y4m_frame_info_t *dest,
const y4m_frame_info_t *src);
/* access or set frame_info fields (level 1) */
int y4m_fi_get_presentation(const y4m_frame_info_t *fi);
int y4m_fi_get_temporal(const y4m_frame_info_t *fi);
int y4m_fi_get_spatial(const y4m_frame_info_t *fi);
void y4m_fi_set_presentation(y4m_frame_info_t *fi, int pres);
void y4m_fi_set_temporal(y4m_frame_info_t *fi, int sampling);
void y4m_fi_set_spatial(y4m_frame_info_t *fi, int sampling);
/* access frame_info xtag_list */
y4m_xtag_list_t *y4m_fi_xtags(y4m_frame_info_t *fi);
/************************************************************************
* blocking read and write functions
*
* o guaranteed to transfer entire payload (or fail)
* o return values:
* 0 (zero) complete success
* -(# of remaining bytes) error (and errno left set)
* +(# of remaining bytes) EOF (for y4m_read only)
*
************************************************************************/
/* read len bytes from fd into buf */
ssize_t y4m_read(int fd, void *buf, size_t len);
/* write len bytes from fd into buf */
ssize_t y4m_write(int fd, const void *buf, size_t len);
/************************************************************************
* callback based read and write
*
* The structures y4m_cb_reader_t and y4m_cb_writer_t must be
* set up by the caller before and of the *_read_*_cb() or
* *_write_*_cb() functions are called. Te return values of
* the read() and write() members have the same meaning as for
* y4m_read() and y4m_write()
*
************************************************************************/
typedef struct y4m_cb_reader_s
{
void * data;
ssize_t (*read)(void * data, void *buf, size_t len);
} y4m_cb_reader_t;
typedef struct y4m_cb_writer_s
{
void * data;
ssize_t (*write)(void * data, const void *buf, size_t len);
} y4m_cb_writer_t;
/* read len bytes from fd into buf */
ssize_t y4m_read_cb(y4m_cb_reader_t * fd, void *buf, size_t len);
/* write len bytes from fd into buf */
ssize_t y4m_write_cb(y4m_cb_writer_t * fd, const void *buf, size_t len);
/************************************************************************
* stream header processing functions
*
* o return values:
* Y4M_OK - success
* Y4M_ERR_* - error (see y4m_strerr() for descriptions)
*
************************************************************************/
/* parse a string of stream header tags */
int y4m_parse_stream_tags(char *s, y4m_stream_info_t *i);
/* read a stream header from file descriptor fd
(the current contents of stream_info are erased first) */
int y4m_read_stream_header(int fd, y4m_stream_info_t *i);
/* read a stream header with a callback reader
(the current contents of stream_info are erased first) */
int y4m_read_stream_header_cb(y4m_cb_reader_t * fd, y4m_stream_info_t *i);
/* write a stream header to file descriptor fd */
int y4m_write_stream_header(int fd, const y4m_stream_info_t *i);
/* write a stream header with a callback writer */
int y4m_write_stream_header_cb(y4m_cb_writer_t * fd, const y4m_stream_info_t *i);
/************************************************************************
* frame processing functions
*
* o return values:
* Y4M_OK - success
* Y4M_ERR_* - error (see y4m_strerr() for descriptions)
*
************************************************************************/
/* write a frame header to file descriptor fd */
int y4m_write_frame_header(int fd,
const y4m_stream_info_t *si,
const y4m_frame_info_t *fi);
/* write a frame header with a callback writer fd */
int y4m_write_frame_header_cb(y4m_cb_writer_t * fd,
const y4m_stream_info_t *si,
const y4m_frame_info_t *fi);
/* write a complete frame (header + data) to file descriptor fd
o planes[] points to 1-4 buffers, one each for image plane */
int y4m_write_frame(int fd, const y4m_stream_info_t *si,
const y4m_frame_info_t *fi, uint8_t * const *planes);
/* write a complete frame (header + data) with a callback writer fd
o planes[] points to 1-4 buffers, one each for image plane */
int y4m_write_frame_cb(y4m_cb_writer_t * fd, const y4m_stream_info_t *si,
const y4m_frame_info_t *fi, uint8_t * const *planes);
/* write a complete frame (header + data), to file descriptor fd
but interleave fields from two separate buffers
o upper_field[] same as planes[] above, but for upper field only
o lower_field[] same as planes[] above, but for lower field only
*/
int y4m_write_fields(int fd, const y4m_stream_info_t *si,
const y4m_frame_info_t *fi,
uint8_t * const *upper_field,
uint8_t * const *lower_field);
/* write a complete frame (header + data), with a callback writer fd
but interleave fields from two separate buffers
o upper_field[] same as planes[] above, but for upper field only
o lower_field[] same as planes[] above, but for lower field only
*/
int y4m_write_fields_cb(y4m_cb_writer_t * fd, const y4m_stream_info_t *si,
const y4m_frame_info_t *fi,
uint8_t * const *upper_field,
uint8_t * const *lower_field);
/* read a frame header from file descriptor fd
(the current contents of frame_info are erased first) */
int y4m_read_frame_header(int fd,
const y4m_stream_info_t *si,
y4m_frame_info_t *fi);
/* read a frame header with callback reader fd
(the current contents of frame_info are erased first) */
int y4m_read_frame_header_cb(y4m_cb_reader_t * fd,
const y4m_stream_info_t *si,
y4m_frame_info_t *fi);
/* read frame data from file descriptor fd
[to be called after y4m_read_frame_header()]
o planes[] points to 1-4 buffers, one each for image plane */
int y4m_read_frame_data(int fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi, uint8_t * const *planes);
/* read frame data with callback reader fd
[to be called after y4m_read_frame_header_cb()]
o planes[] points to 1-4 buffers, one each for image plane */
int y4m_read_frame_data_cb(y4m_cb_reader_t * fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi, uint8_t * const *planes);
/* read frame data from file descriptor fd,
but de-interleave fields into two separate buffers
[to be called after y4m_read_frame_header()]
o upper_field[] same as planes[] above, but for upper field only
o lower_field[] same as planes[] above, but for lower field only
*/
int y4m_read_fields_data(int fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi,
uint8_t * const *upper_field,
uint8_t * const *lower_field);
/* read frame data with callback reader fd,
but de-interleave fields into two separate buffers
[to be called after y4m_read_frame_header_cb()]
o upper_field[] same as planes[] above, but for upper field only
o lower_field[] same as planes[] above, but for lower field only
*/
int y4m_read_fields_data_cb(y4m_cb_reader_t * fd,
const y4m_stream_info_t *si,
y4m_frame_info_t *fi,
uint8_t * const *upper_field,
uint8_t * const *lower_field);
/* read a complete frame (header + data) from file descriptor fd,
o planes[] points to 1-4 buffers, one each for image plane */
int y4m_read_frame(int fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi, uint8_t * const *planes);
/* read a complete frame (header + data) from callback reader fd,
o planes[] points to 1-4 buffers, one each for image plane */
int y4m_read_frame_cb(y4m_cb_reader_t * fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi, uint8_t * const *planes);
/* read a complete frame (header + data) from file descriptor fd,
but de-interleave fields into two separate buffers
o upper_field[] same as planes[] above, but for upper field only
o lower_field[] same as planes[] above, but for lower field only
*/
int y4m_read_fields(int fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi,
uint8_t * const *upper_field,
uint8_t * const *lower_field);
/* read a complete frame (header + data) from callback_reader fd,
but de-interleave fields into two separate buffers
o upper_field[] same as planes[] above, but for upper field only
o lower_field[] same as planes[] above, but for lower field only
*/
int y4m_read_fields_cb(y4m_cb_reader_t * fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi,
uint8_t * const *upper_field,
uint8_t * const *lower_field);
/************************************************************************
* miscellaneous functions
************************************************************************/
/* convenient dump of stream header info via mjpeg_log facility
* - each logged/printed line is prefixed by 'prefix'
*/
void y4m_log_stream_info(log_level_t level, const char *prefix,
const y4m_stream_info_t *i);
/* convert a Y4M_ERR_* error code into mildly explanatory string */
const char *y4m_strerr(int err);
/* set 'allow_unknown_tag' flag for library...
o yn = 0 : unknown header tags will produce a parsing error
o yn = 1 : unknown header tags/values will produce a warning, but
are otherwise passed along via the xtags list
o yn = -1: don't change, just return current setting
return value: previous setting of flag
*/
int y4m_allow_unknown_tags(int yn);
/* set level of "accepted extensions" for the library...
o level = 0: default - conform to original YUV4MPEG2 spec; yield errors
when reading or writing a stream which exceeds it.
o level = 1: allow reading/writing streams which contain non-420jpeg
chroma and/or mixed-mode interlacing
o level = -1: don't change, just return current setting
return value: previous setting of level
*/
int y4m_accept_extensions(int level);
END_CDECLS
/************************************************************************
************************************************************************
Description of the (new!, forever?) YUV4MPEG2 stream format:
STREAM consists of
o one '\n' terminated STREAM-HEADER
o unlimited number of FRAMEs
FRAME consists of
o one '\n' terminated FRAME-HEADER
o "length" octets of planar YCrCb 4:2:0 image data
(if frame is interlaced, then the two fields are interleaved)
STREAM-HEADER consists of
o string "YUV4MPEG2"
o unlimited number TAGGED-FIELDs, each preceded by ' ' separator
o '\n' line terminator
FRAME-HEADER consists of
o string "FRAME"
o unlimited number of TAGGED-FIELDs, each preceded by ' ' separator
o '\n' line terminator
TAGGED-FIELD consists of
o single ascii character tag
o VALUE (which does not contain whitespace)
VALUE consists of
o integer (base 10 ascii representation)
or o RATIO
or o single ascii character
or o non-whitespace ascii string
RATIO consists of
o numerator (integer)
o ':' (a colon)
o denominator (integer)
The currently supported tags for the STREAM-HEADER:
W - [integer] frame width, pixels, should be > 0
H - [integer] frame height, pixels, should be > 0
C - [string] chroma-subsampling/data format
420jpeg (default)
420mpeg2
420paldv
411
422
444 - non-subsampled Y'CbCr
444alpha - Y'CbCr with alpha channel (with Y' black/white point)
mono - Y' plane only
I - [char] interlacing: p - progressive (none)
t - top-field-first
b - bottom-field-first
m - mixed -- see 'I' tag in frame header
? - unknown
F - [ratio] frame-rate, 0:0 == unknown
A - [ratio] sample (pixel) aspect ratio, 0:0 == unknown
X - [character string] 'metadata' (unparsed, but passed around)
The currently supported tags for the FRAME-HEADER:
Ixyz - framing/sampling (required if-and-only-if stream is "Im")
x: t - top-field-first
T - top-field-first and repeat
b - bottom-field-first
B - bottom-field-first and repeat
1 - single progressive frame
2 - double progressive frame (repeat)
3 - triple progressive frame (repeat twice)
y: p - progressive: fields sampled at same time
i - interlaced: fields sampled at different times
z: p - progressive: subsampling over whole frame
i - interlaced: each field subsampled independently
? - unknown (allowed only for non-4:2:0 subsampling)
X - character string 'metadata' (unparsed, but passed around)
************************************************************************
************************************************************************/
/*
THAT'S ALL FOLKS!
Thank you for reading the source code. We hope you have thoroughly
enjoyed the experience.
*/
#ifdef INTERNAL_Y4M_LIBCODE_STUFF_QPX
#define Y4MPRIVATIZE(identifier) identifier
#else
#define Y4MPRIVATIZE(identifier) PRIVATE##identifier
#endif
/*
* Actual structure definitions of structures which you shouldn't touch.
*
*/
/************************************************************************
* 'xtag_list' --- list of unparsed and/or meta/X header tags
*
* Do not touch this structure directly!
*
* Use the y4m_xtag_*() functions (see below).
* You must initialize/finalize this structure before/after use.
************************************************************************/
struct _y4m_xtag_list {
int Y4MPRIVATIZE(count);
char *Y4MPRIVATIZE(tags)[Y4M_MAX_XTAGS];
};
/************************************************************************
* 'stream_info' --- stream header information
*
* Do not touch this structure directly!
*
* Use the y4m_si_*() functions (see below).
* You must initialize/finalize this structure before/after use.
************************************************************************/
struct _y4m_stream_info {
/* values from header/setters */
int Y4MPRIVATIZE(width);
int Y4MPRIVATIZE(height);
int Y4MPRIVATIZE(interlace); /* see Y4M_ILACE_* definitions */
y4m_ratio_t Y4MPRIVATIZE(framerate); /* see Y4M_FPS_* definitions */
y4m_ratio_t Y4MPRIVATIZE(sampleaspect); /* see Y4M_SAR_* definitions */
int Y4MPRIVATIZE(chroma); /* see Y4M_CHROMA_* definitions */
/* mystical X tags */
y4m_xtag_list_t Y4MPRIVATIZE(x_tags);
};
/************************************************************************
* 'frame_info' --- frame header information
*
* Do not touch this structure directly!
*
* Use the y4m_fi_*() functions (see below).
* You must initialize/finalize this structure before/after use.
************************************************************************/
struct _y4m_frame_info {
int Y4MPRIVATIZE(spatial); /* see Y4M_SAMPLING_* definitions */
int Y4MPRIVATIZE(temporal); /* see Y4M_SAMPLING_* definitions */
int Y4MPRIVATIZE(presentation); /* see Y4M_PRESENT_* definitions */
/* mystical X tags */
y4m_xtag_list_t Y4MPRIVATIZE(x_tags);
};
#undef Y4MPRIVATIZE
#endif /* __YUV4MPEG_H__ */
Reference in New Issue View Git Blame Copy Permalink