Mercurial > libavcodec.hg
annotate utils.c @ 480:a7cbee351b55 libavcodec
added ff_idct_put/add
author | bellard |
---|---|
date | Wed, 05 Jun 2002 18:48:07 +0000 |
parents | 000aeeac27a2 |
children | 6f47eef8879f |
rev | line source |
---|---|
0 | 1 /* |
2 * utils for libavcodec | |
429 | 3 * Copyright (c) 2001 Fabrice Bellard. |
0 | 4 * |
429 | 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. | |
0 | 9 * |
429 | 10 * This library is distributed in the hope that it will be useful, |
0 | 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 * Lesser General Public License for more details. | |
0 | 14 * |
429 | 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 | |
0 | 18 */ |
394 | 19 #include "avcodec.h" |
0 | 20 #include "dsputil.h" |
341 | 21 #include "mpegvideo.h" |
80 | 22 #ifdef HAVE_MALLOC_H |
23 #include <malloc.h> | |
24 #endif | |
0 | 25 |
26 /* memory alloc */ | |
394 | 27 void *av_malloc(int size) |
0 | 28 { |
29 void *ptr; | |
77 | 30 #if defined ( ARCH_X86 ) && defined ( HAVE_MEMALIGN ) |
31 ptr = memalign(64,size); | |
32 /* Why 64? | |
33 Indeed, we should align it: | |
34 on 4 for 386 | |
35 on 16 for 486 | |
36 on 32 for 586, PPro - k6-III | |
37 on 64 for K7 (maybe for P3 too). | |
38 Because L1 and L2 caches are aligned on those values. | |
39 But I don't want to code such logic here! | |
40 */ | |
41 #else | |
0 | 42 ptr = malloc(size); |
77 | 43 #endif |
0 | 44 if (!ptr) |
45 return NULL; | |
46 memset(ptr, 0, size); | |
47 return ptr; | |
48 } | |
49 | |
394 | 50 void *av_mallocz(int size) |
51 { | |
52 void *ptr; | |
53 ptr = av_malloc(size); | |
54 if (!ptr) | |
55 return NULL; | |
56 memset(ptr, 0, size); | |
57 return ptr; | |
58 } | |
59 | |
60 /* NOTE: ptr = NULL is explicetly allowed */ | |
61 void av_free(void *ptr) | |
62 { | |
63 /* XXX: this test should not be needed on most libcs */ | |
64 if (ptr) | |
65 free(ptr); | |
66 } | |
67 | |
400 | 68 /* cannot call it directly because of 'void **' casting is not automatic */ |
69 void __av_freep(void **ptr) | |
70 { | |
71 av_free(*ptr); | |
72 *ptr = NULL; | |
73 } | |
74 | |
0 | 75 /* encoder management */ |
76 AVCodec *first_avcodec; | |
77 | |
78 void register_avcodec(AVCodec *format) | |
79 { | |
80 AVCodec **p; | |
81 p = &first_avcodec; | |
82 while (*p != NULL) p = &(*p)->next; | |
83 *p = format; | |
84 format->next = NULL; | |
85 } | |
86 | |
87 int avcodec_open(AVCodecContext *avctx, AVCodec *codec) | |
88 { | |
89 int ret; | |
90 | |
91 avctx->codec = codec; | |
92 avctx->frame_number = 0; | |
374
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
93 if (codec->priv_data_size > 0) { |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
94 avctx->priv_data = av_mallocz(codec->priv_data_size); |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
95 if (!avctx->priv_data) |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
96 return -ENOMEM; |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
97 } else { |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
98 avctx->priv_data = NULL; |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
99 } |
0 | 100 ret = avctx->codec->init(avctx); |
101 if (ret < 0) { | |
394 | 102 av_freep(&avctx->priv_data); |
0 | 103 return ret; |
104 } | |
105 return 0; | |
106 } | |
107 | |
108 int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, | |
109 const short *samples) | |
110 { | |
111 int ret; | |
112 | |
113 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples); | |
114 avctx->frame_number++; | |
115 return ret; | |
116 } | |
117 | |
118 int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, | |
119 const AVPicture *pict) | |
120 { | |
121 int ret; | |
122 | |
123 ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict); | |
124 avctx->frame_number++; | |
125 return ret; | |
126 } | |
127 | |
128 /* decode a frame. return -1 if error, otherwise return the number of | |
129 bytes used. If no frame could be decompressed, *got_picture_ptr is | |
130 zero. Otherwise, it is non zero */ | |
131 int avcodec_decode_video(AVCodecContext *avctx, AVPicture *picture, | |
132 int *got_picture_ptr, | |
133 UINT8 *buf, int buf_size) | |
134 { | |
135 int ret; | |
136 | |
137 ret = avctx->codec->decode(avctx, picture, got_picture_ptr, | |
138 buf, buf_size); | |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
260
diff
changeset
|
139 if (*got_picture_ptr) |
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
260
diff
changeset
|
140 avctx->frame_number++; |
0 | 141 return ret; |
142 } | |
143 | |
144 /* decode an audio frame. return -1 if error, otherwise return the | |
145 *number of bytes used. If no frame could be decompressed, | |
146 *frame_size_ptr is zero. Otherwise, it is the decompressed frame | |
147 *size in BYTES. */ | |
148 int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, | |
149 int *frame_size_ptr, | |
150 UINT8 *buf, int buf_size) | |
151 { | |
152 int ret; | |
153 | |
154 ret = avctx->codec->decode(avctx, samples, frame_size_ptr, | |
155 buf, buf_size); | |
156 avctx->frame_number++; | |
157 return ret; | |
158 } | |
159 | |
160 int avcodec_close(AVCodecContext *avctx) | |
161 { | |
162 if (avctx->codec->close) | |
163 avctx->codec->close(avctx); | |
394 | 164 av_freep(&avctx->priv_data); |
0 | 165 avctx->codec = NULL; |
166 return 0; | |
167 } | |
168 | |
169 AVCodec *avcodec_find_encoder(enum CodecID id) | |
170 { | |
171 AVCodec *p; | |
172 p = first_avcodec; | |
173 while (p) { | |
174 if (p->encode != NULL && p->id == id) | |
175 return p; | |
176 p = p->next; | |
177 } | |
178 return NULL; | |
179 } | |
180 | |
177 | 181 AVCodec *avcodec_find_encoder_by_name(const char *name) |
182 { | |
183 AVCodec *p; | |
184 p = first_avcodec; | |
185 while (p) { | |
186 if (p->encode != NULL && strcmp(name,p->name) == 0) | |
187 return p; | |
188 p = p->next; | |
189 } | |
190 return NULL; | |
191 } | |
192 | |
0 | 193 AVCodec *avcodec_find_decoder(enum CodecID id) |
194 { | |
195 AVCodec *p; | |
196 p = first_avcodec; | |
197 while (p) { | |
198 if (p->decode != NULL && p->id == id) | |
199 return p; | |
200 p = p->next; | |
201 } | |
202 return NULL; | |
203 } | |
204 | |
205 AVCodec *avcodec_find_decoder_by_name(const char *name) | |
206 { | |
207 AVCodec *p; | |
208 p = first_avcodec; | |
209 while (p) { | |
210 if (p->decode != NULL && strcmp(name,p->name) == 0) | |
211 return p; | |
212 p = p->next; | |
213 } | |
214 return NULL; | |
215 } | |
216 | |
217 AVCodec *avcodec_find(enum CodecID id) | |
218 { | |
219 AVCodec *p; | |
220 p = first_avcodec; | |
221 while (p) { | |
222 if (p->id == id) | |
223 return p; | |
224 p = p->next; | |
225 } | |
226 return NULL; | |
227 } | |
228 | |
55 | 229 const char *pix_fmt_str[] = { |
315 | 230 "??", |
55 | 231 "yuv420p", |
232 "yuv422", | |
233 "rgb24", | |
234 "bgr24", | |
235 "yuv422p", | |
236 "yuv444p", | |
237 }; | |
238 | |
0 | 239 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode) |
240 { | |
241 const char *codec_name; | |
242 AVCodec *p; | |
243 char buf1[32]; | |
337 | 244 char channels_str[100]; |
92 | 245 int bitrate; |
0 | 246 |
247 if (encode) | |
248 p = avcodec_find_encoder(enc->codec_id); | |
249 else | |
250 p = avcodec_find_decoder(enc->codec_id); | |
251 | |
252 if (p) { | |
253 codec_name = p->name; | |
254 } else if (enc->codec_name[0] != '\0') { | |
255 codec_name = enc->codec_name; | |
256 } else { | |
257 /* output avi tags */ | |
258 if (enc->codec_type == CODEC_TYPE_VIDEO) { | |
259 snprintf(buf1, sizeof(buf1), "%c%c%c%c", | |
260 enc->codec_tag & 0xff, | |
261 (enc->codec_tag >> 8) & 0xff, | |
262 (enc->codec_tag >> 16) & 0xff, | |
263 (enc->codec_tag >> 24) & 0xff); | |
264 } else { | |
265 snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag); | |
266 } | |
267 codec_name = buf1; | |
268 } | |
269 | |
270 switch(enc->codec_type) { | |
271 case CODEC_TYPE_VIDEO: | |
272 snprintf(buf, buf_size, | |
273 "Video: %s%s", | |
274 codec_name, enc->flags & CODEC_FLAG_HQ ? " (hq)" : ""); | |
55 | 275 if (enc->codec_id == CODEC_ID_RAWVIDEO) { |
276 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
277 ", %s", | |
278 pix_fmt_str[enc->pix_fmt]); | |
279 } | |
0 | 280 if (enc->width) { |
281 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
282 ", %dx%d, %0.2f fps", | |
283 enc->width, enc->height, | |
284 (float)enc->frame_rate / FRAME_RATE_BASE); | |
285 } | |
315 | 286 snprintf(buf + strlen(buf), buf_size - strlen(buf), |
287 ", q=%d-%d", enc->qmin, enc->qmax); | |
288 | |
92 | 289 bitrate = enc->bit_rate; |
0 | 290 break; |
291 case CODEC_TYPE_AUDIO: | |
292 snprintf(buf, buf_size, | |
293 "Audio: %s", | |
294 codec_name); | |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
295 switch (enc->channels) { |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
296 case 1: |
337 | 297 strcpy(channels_str, "mono"); |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
298 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
299 case 2: |
337 | 300 strcpy(channels_str, "stereo"); |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
301 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
302 case 6: |
337 | 303 strcpy(channels_str, "5:1"); |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
304 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
305 default: |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
306 sprintf(channels_str, "%d channels", enc->channels); |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
307 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
308 } |
0 | 309 if (enc->sample_rate) { |
310 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
311 ", %d Hz, %s", | |
312 enc->sample_rate, | |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
313 channels_str); |
0 | 314 } |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
315 |
92 | 316 /* for PCM codecs, compute bitrate directly */ |
317 switch(enc->codec_id) { | |
318 case CODEC_ID_PCM_S16LE: | |
319 case CODEC_ID_PCM_S16BE: | |
320 case CODEC_ID_PCM_U16LE: | |
321 case CODEC_ID_PCM_U16BE: | |
94 | 322 bitrate = enc->sample_rate * enc->channels * 16; |
92 | 323 break; |
324 case CODEC_ID_PCM_S8: | |
325 case CODEC_ID_PCM_U8: | |
326 case CODEC_ID_PCM_ALAW: | |
327 case CODEC_ID_PCM_MULAW: | |
94 | 328 bitrate = enc->sample_rate * enc->channels * 8; |
92 | 329 break; |
330 default: | |
331 bitrate = enc->bit_rate; | |
332 break; | |
333 } | |
0 | 334 break; |
335 default: | |
336 abort(); | |
337 } | |
92 | 338 if (bitrate != 0) { |
0 | 339 snprintf(buf + strlen(buf), buf_size - strlen(buf), |
92 | 340 ", %d kb/s", bitrate / 1000); |
0 | 341 } |
342 } | |
343 | |
55 | 344 /* Picture field are filled with 'ptr' addresses */ |
345 void avpicture_fill(AVPicture *picture, UINT8 *ptr, | |
346 int pix_fmt, int width, int height) | |
347 { | |
348 int size; | |
349 | |
350 size = width * height; | |
351 switch(pix_fmt) { | |
352 case PIX_FMT_YUV420P: | |
353 picture->data[0] = ptr; | |
354 picture->data[1] = picture->data[0] + size; | |
355 picture->data[2] = picture->data[1] + size / 4; | |
356 picture->linesize[0] = width; | |
357 picture->linesize[1] = width / 2; | |
358 picture->linesize[2] = width / 2; | |
359 break; | |
360 case PIX_FMT_YUV422P: | |
361 picture->data[0] = ptr; | |
362 picture->data[1] = picture->data[0] + size; | |
363 picture->data[2] = picture->data[1] + size / 2; | |
364 picture->linesize[0] = width; | |
365 picture->linesize[1] = width / 2; | |
366 picture->linesize[2] = width / 2; | |
367 break; | |
368 case PIX_FMT_YUV444P: | |
369 picture->data[0] = ptr; | |
370 picture->data[1] = picture->data[0] + size; | |
371 picture->data[2] = picture->data[1] + size; | |
372 picture->linesize[0] = width; | |
373 picture->linesize[1] = width; | |
374 picture->linesize[2] = width; | |
375 break; | |
376 case PIX_FMT_RGB24: | |
377 case PIX_FMT_BGR24: | |
378 picture->data[0] = ptr; | |
379 picture->data[1] = NULL; | |
380 picture->data[2] = NULL; | |
381 picture->linesize[0] = width * 3; | |
382 break; | |
383 case PIX_FMT_YUV422: | |
384 picture->data[0] = ptr; | |
385 picture->data[1] = NULL; | |
386 picture->data[2] = NULL; | |
387 picture->linesize[0] = width * 2; | |
388 break; | |
389 default: | |
390 picture->data[0] = NULL; | |
391 picture->data[1] = NULL; | |
392 picture->data[2] = NULL; | |
393 break; | |
394 } | |
395 } | |
396 | |
397 int avpicture_get_size(int pix_fmt, int width, int height) | |
398 { | |
399 int size; | |
400 | |
401 size = width * height; | |
402 switch(pix_fmt) { | |
403 case PIX_FMT_YUV420P: | |
404 size = (size * 3) / 2; | |
405 break; | |
406 case PIX_FMT_YUV422P: | |
407 size = (size * 2); | |
408 break; | |
409 case PIX_FMT_YUV444P: | |
410 size = (size * 3); | |
411 break; | |
412 case PIX_FMT_RGB24: | |
413 case PIX_FMT_BGR24: | |
414 size = (size * 3); | |
415 break; | |
416 case PIX_FMT_YUV422: | |
417 size = (size * 2); | |
418 break; | |
419 default: | |
420 size = -1; | |
421 break; | |
422 } | |
423 return size; | |
424 } | |
425 | |
362 | 426 unsigned avcodec_version( void ) |
427 { | |
428 return LIBAVCODEC_VERSION_INT; | |
429 } | |
55 | 430 |
379 | 431 unsigned avcodec_build( void ) |
432 { | |
433 return LIBAVCODEC_BUILD; | |
434 } | |
435 | |
0 | 436 /* must be called before any other functions */ |
437 void avcodec_init(void) | |
438 { | |
303
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
439 static int inited = 0; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
440 |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
441 if (inited != 0) |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
442 return; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
443 inited = 1; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
444 |
0 | 445 dsputil_init(); |
446 } | |
447 | |
448 /* simple call to use all the codecs */ | |
449 void avcodec_register_all(void) | |
450 { | |
303
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
451 static int inited = 0; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
452 |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
453 if (inited != 0) |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
454 return; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
455 inited = 1; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
456 |
3
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
457 /* encoders */ |
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
458 #ifdef CONFIG_ENCODERS |
0 | 459 register_avcodec(&ac3_encoder); |
460 register_avcodec(&mp2_encoder); | |
260
e1bacfb3f51f
- Added MP3 encoding through libmp3lame contributed by Lennert Buytenhek.
pulento
parents:
177
diff
changeset
|
461 #ifdef CONFIG_MP3LAME |
e1bacfb3f51f
- Added MP3 encoding through libmp3lame contributed by Lennert Buytenhek.
pulento
parents:
177
diff
changeset
|
462 register_avcodec(&mp3lame_encoder); |
e1bacfb3f51f
- Added MP3 encoding through libmp3lame contributed by Lennert Buytenhek.
pulento
parents:
177
diff
changeset
|
463 #endif |
0 | 464 register_avcodec(&mpeg1video_encoder); |
465 register_avcodec(&h263_encoder); | |
466 register_avcodec(&h263p_encoder); | |
467 register_avcodec(&rv10_encoder); | |
468 register_avcodec(&mjpeg_encoder); | |
71 | 469 register_avcodec(&mpeg4_encoder); |
307 | 470 register_avcodec(&msmpeg4v1_encoder); |
471 register_avcodec(&msmpeg4v2_encoder); | |
472 register_avcodec(&msmpeg4v3_encoder); | |
3
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
473 #endif /* CONFIG_ENCODERS */ |
0 | 474 register_avcodec(&rawvideo_codec); |
3
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
475 |
0 | 476 /* decoders */ |
3
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
477 #ifdef CONFIG_DECODERS |
0 | 478 register_avcodec(&h263_decoder); |
71 | 479 register_avcodec(&mpeg4_decoder); |
307 | 480 register_avcodec(&msmpeg4v1_decoder); |
481 register_avcodec(&msmpeg4v2_decoder); | |
482 register_avcodec(&msmpeg4v3_decoder); | |
311 | 483 register_avcodec(&wmv1_decoder); |
0 | 484 register_avcodec(&mpeg_decoder); |
485 register_avcodec(&h263i_decoder); | |
486 register_avcodec(&rv10_decoder); | |
24 | 487 register_avcodec(&mjpeg_decoder); |
322 | 488 register_avcodec(&mp2_decoder); |
3
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
489 register_avcodec(&mp3_decoder); |
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
490 #ifdef CONFIG_AC3 |
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
491 register_avcodec(&ac3_decoder); |
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
492 #endif |
1bdbd869c1f0
added CONFIG_AC3, CONFIG_MPGLIB, CONFIG_DECODERS and CONFIG_ENCODERS (Arpi: don't forget to put CONFIG_DECODERS in mplayer)
glantau
parents:
0
diff
changeset
|
493 #endif /* CONFIG_DECODERS */ |
92 | 494 |
495 /* pcm codecs */ | |
496 | |
497 #define PCM_CODEC(id, name) \ | |
498 register_avcodec(& name ## _encoder); \ | |
499 register_avcodec(& name ## _decoder); \ | |
500 | |
501 PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le); | |
502 PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be); | |
503 PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le); | |
504 PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be); | |
505 PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8); | |
506 PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8); | |
507 PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw); | |
508 PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw); | |
509 | |
510 #undef PCM_CODEC | |
0 | 511 } |
512 | |
341 | 513 /* this should be called after seeking and before trying to decode the next frame */ |
514 void avcodec_flush_buffers(AVCodecContext *avctx) | |
515 { | |
516 MpegEncContext *s = avctx->priv_data; | |
517 s->num_available_buffers=0; | |
518 } | |
519 | |
520 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
521 static int raw_encode_init(AVCodecContext *s) |
0 | 522 { |
523 return 0; | |
524 } | |
525 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
526 static int raw_decode_frame(AVCodecContext *avctx, |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
527 void *data, int *data_size, |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
528 UINT8 *buf, int buf_size) |
0 | 529 { |
530 return -1; | |
531 } | |
532 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
533 static int raw_encode_frame(AVCodecContext *avctx, |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
534 unsigned char *frame, int buf_size, void *data) |
0 | 535 { |
536 return -1; | |
537 } | |
538 | |
539 AVCodec rawvideo_codec = { | |
540 "rawvideo", | |
541 CODEC_TYPE_VIDEO, | |
542 CODEC_ID_RAWVIDEO, | |
543 0, | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
544 raw_encode_init, |
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
545 raw_encode_frame, |
0 | 546 NULL, |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
429
diff
changeset
|
547 raw_decode_frame, |
0 | 548 }; |