rawvideo patch by (Fred Rothganger <rothgang at uiuc dot edu>)
[ffmpeg.git] / libavcodec / raw.c
1 /*
2  * Raw Video Codec
3  * Copyright (c) 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19  
20 /**
21  * @file raw.c
22  * Raw Video Codec
23  */
24  
25 #include "avcodec.h"
26
27
28 typedef struct PixleFormatTag {
29     int pix_fmt;
30     unsigned int fourcc;
31 } PixelFormatTag;
32
33 const PixelFormatTag pixelFormatTags[] = {
34     { PIX_FMT_YUV422, MKTAG('Y', '4', '2', '2') },
35     { -1, 0 },
36 };
37
38 static int findPixelFormat(unsigned int fourcc)
39 {
40     const PixelFormatTag * tags = pixelFormatTags;
41     while (tags->pix_fmt >= 0) {
42         if (tags->fourcc == fourcc)
43             return tags->pix_fmt;
44         tags++;
45     }
46     return PIX_FMT_YUV420P;
47 }
48
49
50 typedef struct RawVideoContext {
51     unsigned char * buffer;  /* block of memory for holding one frame */
52     unsigned char * p;       /* current position in buffer */
53     int             length;  /* number of bytes in buffer */
54 } RawVideoContext;
55
56
57 static int raw_init(AVCodecContext *avctx)
58 {
59     RawVideoContext *context = avctx->priv_data;
60
61     if (avctx->codec_tag) {
62             avctx->pix_fmt = findPixelFormat(avctx->codec_tag);
63     }
64
65         context->length = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);
66         context->buffer = av_malloc(context->length);
67         context->p      = context->buffer;
68
69     if (! context->buffer) {
70         return -1;
71     }
72
73     return 0;
74 }
75
76 static int raw_decode(AVCodecContext *avctx,
77                             void *data, int *data_size,
78                             uint8_t *buf, int buf_size)
79 {
80     RawVideoContext *context = avctx->priv_data;
81
82     AVPicture * picture = (AVPicture *) data;
83
84     /* Early out without copy if packet size == frame size */
85     if (buf_size == context->length  &&  context->p == context->buffer) {
86         avpicture_fill(picture, buf, avctx->pix_fmt, avctx->width, avctx->height);
87         *data_size = sizeof(AVPicture);
88         return buf_size;
89     }
90
91     int bytesNeeded = context->length - (context->p - context->buffer);
92     if (buf_size < bytesNeeded) {
93         memcpy(context->p, buf, buf_size);
94         context->p += buf_size;
95         *data_size = 0;
96         return buf_size;
97     }
98
99     memcpy(context->p, buf, bytesNeeded);
100     context->p = context->buffer;
101     avpicture_fill(picture, context->buffer, avctx->pix_fmt, avctx->width, avctx->height);
102     *data_size = sizeof(AVPicture);
103     return bytesNeeded;
104 }
105
106 static int raw_close(AVCodecContext *avctx)
107 {
108     RawVideoContext *context = avctx->priv_data;
109
110     av_freep(& context->buffer);
111
112     return 0;
113 }
114
115 static int raw_encode(AVCodecContext *avctx,
116                             unsigned char *frame, int buf_size, void *data)
117 {
118         AVPicture * picture = data;
119
120     unsigned char *src;
121         unsigned char *dest = frame;
122     int i, j;
123
124         int w = avctx->width;
125         int h = avctx->height;
126         int size = avpicture_get_size(avctx->pix_fmt, w, h);
127
128     if (size > buf_size) {
129         return -1;
130     }
131
132     switch(avctx->pix_fmt) {
133     case PIX_FMT_YUV420P:
134         for(i=0;i<3;i++) {
135             if (i == 1) {
136                 w >>= 1;
137                 h >>= 1;
138             }
139             src = picture->data[i];
140             for(j=0;j<h;j++) {
141                 memcpy(dest, src, w);
142                 dest += w;
143                 src += picture->linesize[i];
144             }
145         }
146         break;
147     case PIX_FMT_YUV422P:
148         for(i=0;i<3;i++) {
149             if (i == 1) {
150                 w >>= 1;
151             }
152             src = picture->data[i];
153             for(j=0;j<h;j++) {
154                 memcpy(dest, src, w);
155                 dest += w;
156                 src += picture->linesize[i];
157             }
158         }
159         break;
160     case PIX_FMT_YUV444P:
161         for(i=0;i<3;i++) {
162             src = picture->data[i];
163             for(j=0;j<h;j++) {
164                 memcpy(dest, src, w);
165                 dest += w;
166                 src += picture->linesize[i];
167             }
168         }
169         break;
170     case PIX_FMT_YUV422:
171         src = picture->data[0];
172         for(j=0;j<h;j++) {
173             memcpy(dest, src, w * 2);
174             dest += w * 2;
175             src += picture->linesize[0];
176         }
177         break;
178     case PIX_FMT_RGB24:
179     case PIX_FMT_BGR24:
180         src = picture->data[0];
181         for(j=0;j<h;j++) {
182             memcpy(dest, src, w * 3);
183             dest += w * 3;
184             src += picture->linesize[0];
185         }
186         break;
187     default:
188         return -1;
189     }
190
191     return size;
192 }
193
194
195 AVCodec rawvideo_codec = {
196     "rawvideo",
197     CODEC_TYPE_VIDEO,
198     CODEC_ID_RAWVIDEO,
199     sizeof(RawVideoContext),
200     raw_init,
201     raw_encode,
202     raw_close,
203     raw_decode,
204 };