}
}
-/* write a picture to a raw mux */
-static void write_picture(AVFormatContext *s, int index, AVPicture *picture,
- int pix_fmt, int w, int h)
-{
- uint8_t *buf, *src, *dest;
- int size, j, i;
-
- /* XXX: not efficient, should add test if we can take
- directly the AVPicture */
- switch(pix_fmt) {
- case PIX_FMT_YUV420P:
- size = avpicture_get_size(pix_fmt, w, h);
- buf = av_malloc(size);
- if (!buf)
- return;
- dest = buf;
- for(i=0;i<3;i++) {
- if (i == 1) {
- w >>= 1;
- h >>= 1;
- }
- src = picture->data[i];
- for(j=0;j<h;j++) {
- memcpy(dest, src, w);
- dest += w;
- src += picture->linesize[i];
- }
- }
- break;
- case PIX_FMT_YUV422P:
- size = (w * h) * 2;
- buf = av_malloc(size);
- if (!buf)
- return;
- dest = buf;
- for(i=0;i<3;i++) {
- if (i == 1) {
- w >>= 1;
- }
- src = picture->data[i];
- for(j=0;j<h;j++) {
- memcpy(dest, src, w);
- dest += w;
- src += picture->linesize[i];
- }
- }
- break;
- case PIX_FMT_YUV444P:
- size = (w * h) * 3;
- buf = av_malloc(size);
- if (!buf)
- return;
- dest = buf;
- for(i=0;i<3;i++) {
- src = picture->data[i];
- for(j=0;j<h;j++) {
- memcpy(dest, src, w);
- dest += w;
- src += picture->linesize[i];
- }
- }
- break;
- case PIX_FMT_YUV422:
- size = (w * h) * 2;
- buf = av_malloc(size);
- if (!buf)
- return;
- dest = buf;
- src = picture->data[0];
- for(j=0;j<h;j++) {
- memcpy(dest, src, w * 2);
- dest += w * 2;
- src += picture->linesize[0];
- }
- break;
- case PIX_FMT_RGB24:
- case PIX_FMT_BGR24:
- size = (w * h) * 3;
- buf = av_malloc(size);
- if (!buf)
- return;
- dest = buf;
- src = picture->data[0];
- for(j=0;j<h;j++) {
- memcpy(dest, src, w * 3);
- dest += w * 3;
- src += picture->linesize[0];
- }
- break;
- default:
- return;
- }
- av_write_frame(s, index, buf, size);
- av_free(buf);
-}
-
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
{
AVCodecContext *dec;
/* duplicates frame if needed */
/* XXX: pb because no interleaving */
for(i=0;i<nb_frames;i++) {
- if (enc->codec_id != CODEC_ID_RAWVIDEO) {
+ if (s->oformat->flags & AVFMT_RAWPICTURE) {
+ /* raw pictures are written as AVPicture structure to
+ avoid any copies. We support temorarily the older
+ method. */
+ av_write_frame(s, ost->index,
+ (uint8_t *)final_picture, sizeof(AVPicture));
+ } else {
AVFrame big_picture;
memset(&big_picture, 0, sizeof(AVFrame));
if (ost->logfile && enc->stats_out) {
fprintf(ost->logfile, "%s", enc->stats_out);
}
- } else {
- if (s->oformat->flags & AVFMT_RAWPICTURE) {
- /* raw pictures are written as AVPicture structure to
- avoid any copies. We support temorarily the older
- method. */
- av_write_frame(s, ost->index,
- (uint8_t *)final_picture, sizeof(AVPicture));
- } else {
- write_picture(s, ost->index, final_picture, enc->pix_fmt,
- enc->width, enc->height);
- }
}
ost->frame_number++;
}
data_buf = (uint8_t *)samples;
break;
case CODEC_TYPE_VIDEO:
- if (ist->st->codec.codec_id == CODEC_ID_RAWVIDEO) {
- int size;
-
- size = (ist->st->codec.width * ist->st->codec.height);
- avpicture_fill(&picture, ptr,
- ist->st->codec.pix_fmt,
- ist->st->codec.width,
- ist->st->codec.height);
- ret = len;
- } else {
+ {
AVFrame big_picture;
data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
motion_est.o imgconvert.o imgresample.o \
mpeg12.o mpegaudiodec.o pcm.o simple_idct.o \
ratecontrol.o adpcm.o eval.o dv.o error_resilience.o \
- fft.o mdct.o mace.o huffyuv.o cyuv.o opts.o
+ fft.o mdct.o mace.o huffyuv.o cyuv.o opts.o raw.o
ASM_OBJS=
# codecs which are patented in some non free countries like the us
return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
}
+#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
+#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
+
+
void ff_float2fraction(int *nom_arg, int *denom_arg, double f, int max);
--- /dev/null
+/*
+ * Raw Video Codec
+ * Copyright (c) 2001 Fabrice Bellard.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/**
+ * @file raw.c
+ * Raw Video Codec
+ */
+
+#include "avcodec.h"
+
+
+typedef struct PixleFormatTag {
+ int pix_fmt;
+ unsigned int fourcc;
+} PixelFormatTag;
+
+const PixelFormatTag pixelFormatTags[] = {
+ { PIX_FMT_YUV422, MKTAG('Y', '4', '2', '2') },
+ { -1, 0 },
+};
+
+static int findPixelFormat(unsigned int fourcc)
+{
+ const PixelFormatTag * tags = pixelFormatTags;
+ while (tags->pix_fmt >= 0) {
+ if (tags->fourcc == fourcc)
+ return tags->pix_fmt;
+ tags++;
+ }
+ return PIX_FMT_YUV420P;
+}
+
+
+typedef struct RawVideoContext {
+ unsigned char * buffer; /* block of memory for holding one frame */
+ unsigned char * p; /* current position in buffer */
+ int length; /* number of bytes in buffer */
+} RawVideoContext;
+
+
+static int raw_init(AVCodecContext *avctx)
+{
+ RawVideoContext *context = avctx->priv_data;
+
+ if (avctx->codec_tag) {
+ avctx->pix_fmt = findPixelFormat(avctx->codec_tag);
+ }
+
+ context->length = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);
+ context->buffer = av_malloc(context->length);
+ context->p = context->buffer;
+
+ if (! context->buffer) {
+ return -1;
+ }
+
+ return 0;
+}
+
+static int raw_decode(AVCodecContext *avctx,
+ void *data, int *data_size,
+ uint8_t *buf, int buf_size)
+{
+ RawVideoContext *context = avctx->priv_data;
+
+ AVPicture * picture = (AVPicture *) data;
+
+ /* Early out without copy if packet size == frame size */
+ if (buf_size == context->length && context->p == context->buffer) {
+ avpicture_fill(picture, buf, avctx->pix_fmt, avctx->width, avctx->height);
+ *data_size = sizeof(AVPicture);
+ return buf_size;
+ }
+
+ int bytesNeeded = context->length - (context->p - context->buffer);
+ if (buf_size < bytesNeeded) {
+ memcpy(context->p, buf, buf_size);
+ context->p += buf_size;
+ *data_size = 0;
+ return buf_size;
+ }
+
+ memcpy(context->p, buf, bytesNeeded);
+ context->p = context->buffer;
+ avpicture_fill(picture, context->buffer, avctx->pix_fmt, avctx->width, avctx->height);
+ *data_size = sizeof(AVPicture);
+ return bytesNeeded;
+}
+
+static int raw_close(AVCodecContext *avctx)
+{
+ RawVideoContext *context = avctx->priv_data;
+
+ av_freep(& context->buffer);
+
+ return 0;
+}
+
+static int raw_encode(AVCodecContext *avctx,
+ unsigned char *frame, int buf_size, void *data)
+{
+ AVPicture * picture = data;
+
+ unsigned char *src;
+ unsigned char *dest = frame;
+ int i, j;
+
+ int w = avctx->width;
+ int h = avctx->height;
+ int size = avpicture_get_size(avctx->pix_fmt, w, h);
+
+ if (size > buf_size) {
+ return -1;
+ }
+
+ switch(avctx->pix_fmt) {
+ case PIX_FMT_YUV420P:
+ for(i=0;i<3;i++) {
+ if (i == 1) {
+ w >>= 1;
+ h >>= 1;
+ }
+ src = picture->data[i];
+ for(j=0;j<h;j++) {
+ memcpy(dest, src, w);
+ dest += w;
+ src += picture->linesize[i];
+ }
+ }
+ break;
+ case PIX_FMT_YUV422P:
+ for(i=0;i<3;i++) {
+ if (i == 1) {
+ w >>= 1;
+ }
+ src = picture->data[i];
+ for(j=0;j<h;j++) {
+ memcpy(dest, src, w);
+ dest += w;
+ src += picture->linesize[i];
+ }
+ }
+ break;
+ case PIX_FMT_YUV444P:
+ for(i=0;i<3;i++) {
+ src = picture->data[i];
+ for(j=0;j<h;j++) {
+ memcpy(dest, src, w);
+ dest += w;
+ src += picture->linesize[i];
+ }
+ }
+ break;
+ case PIX_FMT_YUV422:
+ src = picture->data[0];
+ for(j=0;j<h;j++) {
+ memcpy(dest, src, w * 2);
+ dest += w * 2;
+ src += picture->linesize[0];
+ }
+ break;
+ case PIX_FMT_RGB24:
+ case PIX_FMT_BGR24:
+ src = picture->data[0];
+ for(j=0;j<h;j++) {
+ memcpy(dest, src, w * 3);
+ dest += w * 3;
+ src += picture->linesize[0];
+ }
+ break;
+ default:
+ return -1;
+ }
+
+ return size;
+}
+
+
+AVCodec rawvideo_codec = {
+ "rawvideo",
+ CODEC_TYPE_VIDEO,
+ CODEC_ID_RAWVIDEO,
+ sizeof(RawVideoContext),
+ raw_init,
+ raw_encode,
+ raw_close,
+ raw_decode,
+};
return ((h/c)<<32) + l/c;
}
-
-static int raw_encode_init(AVCodecContext *s)
-{
- return 0;
-}
-
-static int raw_decode_frame(AVCodecContext *avctx,
- void *data, int *data_size,
- uint8_t *buf, int buf_size)
-{
- return -1;
-}
-
-static int raw_encode_frame(AVCodecContext *avctx,
- unsigned char *frame, int buf_size, void *data)
-{
- return -1;
-}
-
-AVCodec rawvideo_codec = {
- "rawvideo",
- CODEC_TYPE_VIDEO,
- CODEC_ID_RAWVIDEO,
- 0,
- raw_encode_init,
- raw_encode_frame,
- NULL,
- raw_decode_frame,
-};
extern AVOutputFormat yuv4mpegpipe_oformat;
/* utils.c */
-#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
-#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
-
void av_register_input_format(AVInputFormat *format);
void av_register_output_format(AVOutputFormat *format);
AVOutputFormat *guess_stream_format(const char *short_name,
{ CODEC_ID_HUFFYUV, MKTAG('h', 'f', 'y', 'u') },
{ CODEC_ID_CYUV, MKTAG('C', 'Y', 'U', 'V') },
{ CODEC_ID_CYUV, MKTAG('c', 'y', 'u', 'v') },
+ { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '2', '2') },
{ 0, 0 },
};
stream = &s->streams[i]->codec;
+ /* FourCC should really be set by the codec itself */
+ if (! stream->codec_tag) {
+ stream->codec_tag = codec_get_bmp_tag(stream->codec_id);
+ }
+
/* stream generic header */
strh = start_tag(pb, "strh");
switch(stream->codec_type) {
case CODEC_TYPE_VIDEO:
put_tag(pb, "vids");
- put_le32(pb, codec_get_bmp_tag(stream->codec_id));
+ put_le32(pb, stream->codec_tag);
put_le32(pb, 0); /* flags */
put_le16(pb, 0); /* priority */
put_le16(pb, 0); /* language */
projects / frescor / ffmpeg.git / commitdiff