static int internal_read_444_fields(int fd,
const y4m_stream_info_t *si,
y4m_frame_info_t *fi,
uint8_t * const upper_field[3],
uint8_t * const lower_field[3])
{
int i, y, err;
int width = y4m_si_get_width(si);
int height = y4m_si_get_height(si);
/* Read frame header */
if ((err = y4m_read_frame_header(fd, si, fi)) != Y4M_OK) return err;
/* Read Y', Cb, and Cr planes */
for (i = 0; i < 3; i++) {
uint8_t *srctop = upper_field[i];
uint8_t *srcbot = lower_field[i];
/* alternately write one line from each */
for (y = 0; y < height; y += 2) {
if (y4m_read(fd, srctop, width)) return Y4M_ERR_SYSTEM;
srctop += width;
if (y4m_read(fd, srcbot, width)) return Y4M_ERR_SYSTEM;
srcbot += width;
}
}
return Y4M_OK;
}
int y4m_read_fields(int fd, y4m_stream_info_t *si, y4m_frame_info_t *fi,
unsigned char *upper_field[3],
unsigned char *lower_field[3])
{
int i, y, err;
int width = si->width;
int height = si->height;
/* Read frame header */
if ((err = y4m_read_frame_header(fd, fi)) != Y4M_OK) return err;
/* Read Y', Cb, and Cr planes */
for (i = 0; i < 3; i++) {
unsigned char *srctop = upper_field[i];
unsigned char *srcbot = lower_field[i];
/* alternately write one line from each */
for (y = 0; y < height; y += 2) {
if (y4m_read(fd, srctop, width)) return Y4M_ERR_SYSTEM;
srctop += width;
if (y4m_read(fd, srcbot, width)) return Y4M_ERR_SYSTEM;
srcbot += width;
}
/* for chroma, width/height are half as big */
if (i == 0) {
width /= 2;
height /= 2;
}
}
return Y4M_OK;
}
static
void read_ppm_into_two_buffers(int fd,
uint8_t *buffers[],
uint8_t *buffers2[],
uint8_t *rowbuffer,
int width, int height, int bgr)
{
int x, y;
uint8_t *pixels;
uint8_t *R = buffers[0];
uint8_t *G = buffers[1];
uint8_t *B = buffers[2];
uint8_t *R2 = buffers2[0];
uint8_t *G2 = buffers2[1];
uint8_t *B2 = buffers2[2];
mjpeg_debug("read into two buffers, %dx%d", width, height);
height /= 2;
for (y = 0; y < height; y++) {
pixels = rowbuffer;
if (y4m_read(fd, pixels, width * 3))
mjpeg_error_exit1("read error A y=%d", y);
if (bgr) {
for (x = 0; x < width; x++) {
*(B++) = *(pixels++);
*(G++) = *(pixels++);
*(R++) = *(pixels++);
}
} else {
for (x = 0; x < width; x++) {
*(R++) = *(pixels++);
*(G++) = *(pixels++);
*(B++) = *(pixels++);
}
}
pixels = rowbuffer;
if (y4m_read(fd, pixels, width * 3))
mjpeg_error_exit1("read error B y=%d", y);
if (bgr) {
for (x = 0; x < width; x++) {
*(B2++) = *(pixels++);
*(G2++) = *(pixels++);
*(R2++) = *(pixels++);
}
} else {
for (x = 0; x < width; x++) {
*(R2++) = *(pixels++);
*(G2++) = *(pixels++);
*(B2++) = *(pixels++);
}
}
}
}
static
void read_ppm_into_one_buffer(int fd,
uint8_t *buffers[],
uint8_t *rowbuffer,
int width, int height, int bgr)
{
int x, y;
uint8_t *pixels;
uint8_t *R = buffers[0];
uint8_t *G = buffers[1];
uint8_t *B = buffers[2];
for (y = 0; y < height; y++) {
pixels = rowbuffer;
y4m_read(fd, pixels, width * 3);
if (bgr) {
for (x = 0; x < width; x++) {
*(B++) = *(pixels++);
*(G++) = *(pixels++);
*(R++) = *(pixels++);
}
} else {
for (x = 0; x < width; x++) {
*(R++) = *(pixels++);
*(G++) = *(pixels++);
*(B++) = *(pixels++);
}
}
}
}
static
int read_ppm_header(int fd, int *width, int *height)
{
char s[6];
int incomment;
int n;
int maxval = 0;
*width = 0;
*height = 0;
/* look for "P6" */
n = y4m_read(fd, s, 3);
if (n > 0)
return 1; /* EOF */
if ((n < 0) || (strncmp(s, "P6", 2)))
mjpeg_error_exit1("Bad Raw PPM magic!");
incomment = 0;
DO_SKIP_WHITESPACE();
DO_READ_NUMBER(*width);
DO_SKIP_WHITESPACE();
DO_READ_NUMBER(*height);
DO_SKIP_WHITESPACE();
DO_READ_NUMBER(maxval);
if (maxval != 255)
mjpeg_error_exit1("Expecting maxval == 255, not %d!", maxval);
return 0;
}
int y4m_read_stream_header(stream_t *s, y4m_stream_info_t *i)
{
char line[Y4M_LINE_MAX];
char *p;
int n;
int err;
/* read the header line */
for (n = 0, p = line; n < Y4M_LINE_MAX; n++, p++) {
if (y4m_read(s, p, 1))
return Y4M_ERR_SYSTEM;
if (*p == '\n') {
*p = '\0'; /* Replace linefeed by end of string */
break;
}
}
if (n >= Y4M_LINE_MAX)
return Y4M_ERR_HEADER;
/* look for keyword in header */
if (strncmp(line, Y4M_MAGIC, strlen(Y4M_MAGIC)))
return Y4M_ERR_MAGIC;
if ((err = y4m_parse_stream_tags(line + strlen(Y4M_MAGIC), i)) != Y4M_OK)
return err;
i->framelength = (i->height * i->width) * 3 / 2;
return Y4M_OK;
}
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)
{
int p;
int planes = y4m_si_get_plane_count(si);
const int maxrbuf=32*1024;
uint8_t *rbuf=_y4m_alloc(maxrbuf);
int rbufpos=0,rbuflen=0;
/* Read each plane */
for (p = 0; p < planes; p++) {
uint8_t *dsttop = upper_field[p];
uint8_t *dstbot = lower_field[p];
int height = y4m_si_get_plane_height(si, p);
int width = y4m_si_get_plane_width(si, p);
int y;
/* alternately read one line into each field */
for (y = 0; y < height; y += 2) {
if( width*2 >= maxrbuf ) {
if (y4m_read(fd, dsttop, width)) goto y4merr;
if (y4m_read(fd, dstbot, width)) goto y4merr;
} else {
if( rbufpos==rbuflen ) {
rbuflen=(height-y)*width;
if( rbuflen>maxrbuf )
rbuflen=maxrbuf-maxrbuf%(2*width);
if( y4m_read(fd,rbuf,rbuflen) )
goto y4merr;
rbufpos=0;
}
memcpy(dsttop,rbuf+rbufpos,width); rbufpos+=width;
memcpy(dstbot,rbuf+rbufpos,width); rbufpos+=width;
}
dsttop+=width;
dstbot+=width;
}
}
_y4m_free(rbuf);
return Y4M_OK;
y4merr:
_y4m_free(rbuf);
return Y4M_ERR_SYSTEM;
}
int y4m_read_frame(stream_t *s, y4m_stream_info_t *si,
y4m_frame_info_t *fi, unsigned char *yuv[3])
{
int err;
int w = si->width;
int h = si->height;
/* Read frame header */
if ((err = y4m_read_frame_header(s, fi)) != Y4M_OK) return err;
/* Read luminance scanlines */
if (y4m_read(s, yuv[0], w*h)) return Y4M_ERR_SYSTEM;
/* Read chrominance scanlines */
if (y4m_read(s, yuv[1], w*h/4)) return Y4M_ERR_SYSTEM;
if (y4m_read(s, yuv[2], w*h/4)) return Y4M_ERR_SYSTEM;
return Y4M_OK;
}
int y4m_read_frame_header(int fd,
const y4m_stream_info_t *si,
y4m_frame_info_t *fi)
{
char line[Y4M_LINE_MAX];
char *p;
int n;
ssize_t remain;
/* start with a clean slate */
y4m_clear_frame_info(fi);
/* This is more clever than read_stream_header...
Try to read "FRAME\n" all at once, and don't try to parse
if nothing else is there...
*/
remain = y4m_read(fd, line, sizeof(Y4M_FRAME_MAGIC)-1+1); /* -'\0', +'\n' */
if (remain < 0) return Y4M_ERR_SYSTEM;
if (remain > 0) {
/* A clean EOF should end exactly at a frame-boundary */
if (remain == sizeof(Y4M_FRAME_MAGIC))
return Y4M_ERR_EOF;
else
return Y4M_ERR_BADEOF;
}
if (strncmp(line, Y4M_FRAME_MAGIC, sizeof(Y4M_FRAME_MAGIC)-1))
return Y4M_ERR_MAGIC;
if (line[sizeof(Y4M_FRAME_MAGIC)-1] == '\n')
return Y4M_OK; /* done -- no tags: that was the end-of-line. */
if (line[sizeof(Y4M_FRAME_MAGIC)-1] != Y4M_DELIM[0]) {
return Y4M_ERR_MAGIC; /* wasn't a space -- what was it? */
}
/* proceed to get the tags... (overwrite the magic) */
for (n = 0, p = line; n < Y4M_LINE_MAX; n++, p++) {
if (y4m_read(fd, p, 1))
return Y4M_ERR_SYSTEM;
if (*p == '\n') {
*p = '\0'; /* Replace linefeed by end of string */
break;
}
}
if (n >= Y4M_LINE_MAX) return Y4M_ERR_HEADER;
/* non-zero on error */
return y4m_parse_frame_tags(line, si, fi);
}
static int internal_read_422_frame(int fd,
const y4m_stream_info_t *si,
y4m_frame_info_t *fi,
uint8_t * const yuv[3])
{
int err;
int w = y4m_si_get_width(si);
int h = y4m_si_get_height(si);
/* Read frame header */
if ((err = y4m_read_frame_header(fd, si, fi)) != Y4M_OK) return err;
/* Read luminance scanlines */
if (y4m_read(fd, yuv[0], w*h)) return Y4M_ERR_SYSTEM;
/* Read chrominance scanlines */
if (y4m_read(fd, yuv[1], w*h/2)) return Y4M_ERR_SYSTEM;
if (y4m_read(fd, yuv[2], w*h/2)) return Y4M_ERR_SYSTEM;
return Y4M_OK;
}
int y4m_read_frame_data(int fd, const y4m_stream_info_t *si,
y4m_frame_info_t *fi, uint8_t * const *frame)
{
int planes = y4m_si_get_plane_count(si);
int p;
/* Read each plane */
for (p = 0; p < planes; p++) {
int w = y4m_si_get_plane_width(si, p);
int h = y4m_si_get_plane_height(si, p);
if (y4m_read(fd, frame[p], w*h)) return Y4M_ERR_SYSTEM;
}
return Y4M_OK;
}
/* read len bytes from fd into buf */
static ssize_t y4m_read_fd(void * data, void *buf, size_t len)
{
int * f = (int*)data;
return y4m_read(*f, buf, len);
}
