Mercurial > libavcodec.hg
comparison raw.c @ 1139:6842feb093c1 libavcodec
rawvideo patch by (Fred Rothganger <rothgang at uiuc dot edu>)
author | michaelni |
---|---|
date | Sun, 16 Mar 2003 21:03:20 +0000 |
parents | |
children | e3c231c7eb04 |
comparison
equal
deleted
inserted
replaced
1138:e10e841c9bf0 | 1139:6842feb093c1 |
---|---|
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 }; |