3 * Copyright (c) 2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * @file libavcodec/utils.c
28 /* needed for mkstemp() */
29 #define _XOPEN_SOURCE 600
31 #include "libavutil/avstring.h"
32 #include "libavutil/integer.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/pixdesc.h"
38 #include "imgconvert.h"
39 #include "audioconvert.h"
40 #include "libxvid_internal.h"
50 static int volatile entangled_thread_counter
=0;
51 int (*ff_lockmgr_cb
)(void **mutex
, enum AVLockOp op
);
52 static void *codec_mutex
;
54 void *av_fast_realloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
59 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
61 ptr
= av_realloc(ptr
, *size
);
62 if(!ptr
) //we could set this to the unmodified min_size but this is safer if the user lost the ptr and uses NULL now
68 void av_fast_malloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
73 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
75 *p
= av_malloc(*size
);
79 /* encoder management */
80 static AVCodec
*first_avcodec
= NULL
;
82 AVCodec
*av_codec_next(AVCodec
*c
){
84 else return first_avcodec
;
87 void avcodec_register(AVCodec
*codec
)
92 while (*p
!= NULL
) p
= &(*p
)->next
;
97 #if LIBAVCODEC_VERSION_MAJOR < 53
98 void register_avcodec(AVCodec
*codec
)
100 avcodec_register(codec
);
104 void avcodec_set_dimensions(AVCodecContext
*s
, int width
, int height
){
105 s
->coded_width
= width
;
106 s
->coded_height
= height
;
107 s
->width
= -((-width
)>>s
->lowres
);
108 s
->height
= -((-height
)>>s
->lowres
);
111 typedef struct InternalBuffer
{
117 enum PixelFormat pix_fmt
;
120 #define INTERNAL_BUFFER_SIZE 32
122 void avcodec_align_dimensions2(AVCodecContext
*s
, int *width
, int *height
, int linesize_align
[4]){
127 case PIX_FMT_YUV420P
:
128 case PIX_FMT_YUYV422
:
129 case PIX_FMT_UYVY422
:
130 case PIX_FMT_YUV422P
:
131 case PIX_FMT_YUV440P
:
132 case PIX_FMT_YUV444P
:
134 case PIX_FMT_GRAY16BE
:
135 case PIX_FMT_GRAY16LE
:
136 case PIX_FMT_YUVJ420P
:
137 case PIX_FMT_YUVJ422P
:
138 case PIX_FMT_YUVJ440P
:
139 case PIX_FMT_YUVJ444P
:
140 case PIX_FMT_YUVA420P
:
141 w_align
= 16; //FIXME check for non mpeg style codecs and use less alignment
143 if(s
->codec_id
== CODEC_ID_MPEG2VIDEO
|| s
->codec_id
== CODEC_ID_MJPEG
|| s
->codec_id
== CODEC_ID_AMV
|| s
->codec_id
== CODEC_ID_THP
)
144 h_align
= 32; // interlaced is rounded up to 2 MBs
146 case PIX_FMT_YUV411P
:
147 case PIX_FMT_UYYVYY411
:
151 case PIX_FMT_YUV410P
:
152 if(s
->codec_id
== CODEC_ID_SVQ1
){
157 if(s
->codec_id
== CODEC_ID_RPZA
){
164 if(s
->codec_id
== CODEC_ID_SMC
){
170 if((s
->codec_id
== CODEC_ID_MSZH
) || (s
->codec_id
== CODEC_ID_ZLIB
)){
181 *width
= FFALIGN(*width
, w_align
);
182 *height
= FFALIGN(*height
, h_align
);
183 if(s
->codec_id
== CODEC_ID_H264
)
184 *height
+=2; // some of the optimized chroma MC reads one line too much
189 linesize_align
[3] = STRIDE_ALIGN
;
190 //STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
191 //we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
192 //picture size unneccessarily in some cases. The solution here is not
193 //pretty and better ideas are welcome!
195 if(s
->codec_id
== CODEC_ID_SVQ1
|| s
->codec_id
== CODEC_ID_VP5
||
196 s
->codec_id
== CODEC_ID_VP6
|| s
->codec_id
== CODEC_ID_VP6F
||
197 s
->codec_id
== CODEC_ID_VP6A
) {
200 linesize_align
[2] = 16;
205 void avcodec_align_dimensions(AVCodecContext
*s
, int *width
, int *height
){
206 int chroma_shift
= av_pix_fmt_descriptors
[s
->pix_fmt
].log2_chroma_w
;
207 int linesize_align
[4];
209 avcodec_align_dimensions2(s
, width
, height
, linesize_align
);
210 align
= FFMAX(linesize_align
[0], linesize_align
[3]);
211 linesize_align
[1] <<= chroma_shift
;
212 linesize_align
[2] <<= chroma_shift
;
213 align
= FFMAX3(align
, linesize_align
[1], linesize_align
[2]);
214 *width
=FFALIGN(*width
, align
);
217 int avcodec_check_dimensions(void *av_log_ctx
, unsigned int w
, unsigned int h
){
218 if((int)w
>0 && (int)h
>0 && (w
+128)*(uint64_t)(h
+128) < INT_MAX
/8)
221 av_log(av_log_ctx
, AV_LOG_ERROR
, "picture size invalid (%ux%u)\n", w
, h
);
225 int avcodec_default_get_buffer(AVCodecContext
*s
, AVFrame
*pic
){
232 if(pic
->data
[0]!=NULL
) {
233 av_log(s
, AV_LOG_ERROR
, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
236 if(s
->internal_buffer_count
>= INTERNAL_BUFFER_SIZE
) {
237 av_log(s
, AV_LOG_ERROR
, "internal_buffer_count overflow (missing release_buffer?)\n");
241 if(avcodec_check_dimensions(s
,w
,h
))
244 if(s
->internal_buffer
==NULL
){
245 s
->internal_buffer
= av_mallocz((INTERNAL_BUFFER_SIZE
+1)*sizeof(InternalBuffer
));
248 s
->internal_buffer
= av_fast_realloc(
250 &s
->internal_buffer_size
,
251 sizeof(InternalBuffer
)*FFMAX(99, s
->internal_buffer_count
+1)/*FIXME*/
255 buf
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
256 picture_number
= &(((InternalBuffer
*)s
->internal_buffer
)[INTERNAL_BUFFER_SIZE
]).last_pic_num
; //FIXME ugly hack
259 if(buf
->base
[0] && (buf
->width
!= w
|| buf
->height
!= h
|| buf
->pix_fmt
!= s
->pix_fmt
)){
261 av_freep(&buf
->base
[i
]);
267 pic
->age
= *picture_number
- buf
->last_pic_num
;
268 buf
->last_pic_num
= *picture_number
;
270 int h_chroma_shift
, v_chroma_shift
;
277 avcodec_get_chroma_sub_sample(s
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
279 avcodec_align_dimensions2(s
, &w
, &h
, stride_align
);
281 if(!(s
->flags
&CODEC_FLAG_EMU_EDGE
)){
287 // NOTE: do not align linesizes individually, this breaks e.g. assumptions
288 // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
289 ff_fill_linesize(&picture
, s
->pix_fmt
, w
);
290 // increase alignment of w for next try (rhs gives the lowest bit set in w)
295 unaligned
|= picture
.linesize
[i
] % stride_align
[i
];
299 tmpsize
= ff_fill_pointer(&picture
, NULL
, s
->pix_fmt
, h
);
303 for (i
=0; i
<3 && picture
.data
[i
+1]; i
++)
304 size
[i
] = picture
.data
[i
+1] - picture
.data
[i
];
305 size
[i
] = tmpsize
- (picture
.data
[i
] - picture
.data
[0]);
307 buf
->last_pic_num
= -256*256*256*64;
308 memset(buf
->base
, 0, sizeof(buf
->base
));
309 memset(buf
->data
, 0, sizeof(buf
->data
));
311 for(i
=0; i
<4 && size
[i
]; i
++){
312 const int h_shift
= i
==0 ?
0 : h_chroma_shift
;
313 const int v_shift
= i
==0 ?
0 : v_chroma_shift
;
315 buf
->linesize
[i
]= picture
.linesize
[i
];
317 buf
->base
[i
]= av_malloc(size
[i
]+16); //FIXME 16
318 if(buf
->base
[i
]==NULL
) return -1;
319 memset(buf
->base
[i
], 128, size
[i
]);
321 // no edge if EDEG EMU or not planar YUV
322 if((s
->flags
&CODEC_FLAG_EMU_EDGE
) || !size
[2])
323 buf
->data
[i
] = buf
->base
[i
];
325 buf
->data
[i
] = buf
->base
[i
] + FFALIGN((buf
->linesize
[i
]*EDGE_WIDTH
>>v_shift
) + (EDGE_WIDTH
>>h_shift
), stride_align
[i
]);
327 if(size
[1] && !size
[2])
328 ff_set_systematic_pal((uint32_t*)buf
->data
[1], s
->pix_fmt
);
329 buf
->width
= s
->width
;
330 buf
->height
= s
->height
;
331 buf
->pix_fmt
= s
->pix_fmt
;
332 pic
->age
= 256*256*256*64;
334 pic
->type
= FF_BUFFER_TYPE_INTERNAL
;
337 pic
->base
[i
]= buf
->base
[i
];
338 pic
->data
[i
]= buf
->data
[i
];
339 pic
->linesize
[i
]= buf
->linesize
[i
];
341 s
->internal_buffer_count
++;
343 pic
->reordered_opaque
= s
->reordered_opaque
;
345 if(s
->debug
&FF_DEBUG_BUFFERS
)
346 av_log(s
, AV_LOG_DEBUG
, "default_get_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
351 void avcodec_default_release_buffer(AVCodecContext
*s
, AVFrame
*pic
){
353 InternalBuffer
*buf
, *last
;
355 assert(pic
->type
==FF_BUFFER_TYPE_INTERNAL
);
356 assert(s
->internal_buffer_count
);
358 buf
= NULL
; /* avoids warning */
359 for(i
=0; i
<s
->internal_buffer_count
; i
++){ //just 3-5 checks so is not worth to optimize
360 buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
361 if(buf
->data
[0] == pic
->data
[0])
364 assert(i
< s
->internal_buffer_count
);
365 s
->internal_buffer_count
--;
366 last
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
368 FFSWAP(InternalBuffer
, *buf
, *last
);
372 // pic->base[i]=NULL;
374 //printf("R%X\n", pic->opaque);
376 if(s
->debug
&FF_DEBUG_BUFFERS
)
377 av_log(s
, AV_LOG_DEBUG
, "default_release_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
380 int avcodec_default_reget_buffer(AVCodecContext
*s
, AVFrame
*pic
){
384 /* If no picture return a new buffer */
385 if(pic
->data
[0] == NULL
) {
386 /* We will copy from buffer, so must be readable */
387 pic
->buffer_hints
|= FF_BUFFER_HINTS_READABLE
;
388 return s
->get_buffer(s
, pic
);
391 /* If internal buffer type return the same buffer */
392 if(pic
->type
== FF_BUFFER_TYPE_INTERNAL
) {
393 pic
->reordered_opaque
= s
->reordered_opaque
;
398 * Not internal type and reget_buffer not overridden, emulate cr buffer
401 for(i
= 0; i
< 4; i
++)
402 pic
->data
[i
] = pic
->base
[i
] = NULL
;
404 /* Allocate new frame */
405 if (s
->get_buffer(s
, pic
))
407 /* Copy image data from old buffer to new buffer */
408 av_picture_copy((AVPicture
*)pic
, (AVPicture
*)&temp_pic
, s
->pix_fmt
, s
->width
,
410 s
->release_buffer(s
, &temp_pic
); // Release old frame
414 int avcodec_default_execute(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
),void *arg
, int *ret
, int count
, int size
){
417 for(i
=0; i
<count
; i
++){
418 int r
= func(c
, (char*)arg
+ i
*size
);
424 int avcodec_default_execute2(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
, int jobnr
, int threadnr
),void *arg
, int *ret
, int count
){
427 for(i
=0; i
<count
; i
++){
428 int r
= func(c
, arg
, i
, 0);
434 enum PixelFormat
avcodec_default_get_format(struct AVCodecContext
*s
, const enum PixelFormat
*fmt
){
435 while (*fmt
!= PIX_FMT_NONE
&& ff_is_hwaccel_pix_fmt(*fmt
))
440 void avcodec_get_frame_defaults(AVFrame
*pic
){
441 memset(pic
, 0, sizeof(AVFrame
));
443 pic
->pts
= AV_NOPTS_VALUE
;
447 AVFrame
*avcodec_alloc_frame(void){
448 AVFrame
*pic
= av_malloc(sizeof(AVFrame
));
450 if(pic
==NULL
) return NULL
;
452 avcodec_get_frame_defaults(pic
);
457 int attribute_align_arg
avcodec_open(AVCodecContext
*avctx
, AVCodec
*codec
)
461 /* If there is a user-supplied mutex locking routine, call it. */
463 if ((*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_OBTAIN
))
467 entangled_thread_counter
++;
468 if(entangled_thread_counter
!= 1){
469 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
473 if(avctx
->codec
|| !codec
)
476 if (codec
->priv_data_size
> 0) {
477 avctx
->priv_data
= av_mallocz(codec
->priv_data_size
);
478 if (!avctx
->priv_data
) {
479 ret
= AVERROR(ENOMEM
);
483 avctx
->priv_data
= NULL
;
486 if(avctx
->coded_width
&& avctx
->coded_height
)
487 avcodec_set_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
);
488 else if(avctx
->width
&& avctx
->height
)
489 avcodec_set_dimensions(avctx
, avctx
->width
, avctx
->height
);
491 #define SANE_NB_CHANNELS 128U
492 if (((avctx
->coded_width
|| avctx
->coded_height
)
493 && avcodec_check_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
))
494 || avctx
->channels
> SANE_NB_CHANNELS
) {
495 ret
= AVERROR(EINVAL
);
499 avctx
->codec
= codec
;
500 if ((avctx
->codec_type
== CODEC_TYPE_UNKNOWN
|| avctx
->codec_type
== codec
->type
) &&
501 avctx
->codec_id
== CODEC_ID_NONE
) {
502 avctx
->codec_type
= codec
->type
;
503 avctx
->codec_id
= codec
->id
;
505 if(avctx
->codec_id
!= codec
->id
|| avctx
->codec_type
!= codec
->type
){
506 av_log(avctx
, AV_LOG_ERROR
, "codec type or id mismatches\n");
509 avctx
->frame_number
= 0;
510 if(avctx
->codec
->init
){
511 ret
= avctx
->codec
->init(avctx
);
518 entangled_thread_counter
--;
520 /* Release any user-supplied mutex. */
522 (*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_RELEASE
);
526 av_freep(&avctx
->priv_data
);
531 int attribute_align_arg
avcodec_encode_audio(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
532 const short *samples
)
534 if(buf_size
< FF_MIN_BUFFER_SIZE
&& 0){
535 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
538 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || samples
){
539 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, samples
);
540 avctx
->frame_number
++;
546 int attribute_align_arg
avcodec_encode_video(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
549 if(buf_size
< FF_MIN_BUFFER_SIZE
){
550 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
553 if(avcodec_check_dimensions(avctx
,avctx
->width
,avctx
->height
))
555 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || pict
){
556 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, pict
);
557 avctx
->frame_number
++;
558 emms_c(); //needed to avoid an emms_c() call before every return;
565 int avcodec_encode_subtitle(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
566 const AVSubtitle
*sub
)
569 if(sub
->start_display_time
) {
570 av_log(avctx
, AV_LOG_ERROR
, "start_display_time must be 0.\n");
573 if(sub
->num_rects
== 0 || !sub
->rects
)
575 ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, sub
);
576 avctx
->frame_number
++;
580 #if LIBAVCODEC_VERSION_MAJOR < 53
581 int attribute_align_arg
avcodec_decode_video(AVCodecContext
*avctx
, AVFrame
*picture
,
582 int *got_picture_ptr
,
583 const uint8_t *buf
, int buf_size
)
586 av_init_packet(&avpkt
);
588 avpkt
.size
= buf_size
;
589 // HACK for CorePNG to decode as normal PNG by default
590 avpkt
.flags
= AV_PKT_FLAG_KEY
;
592 return avcodec_decode_video2(avctx
, picture
, got_picture_ptr
, &avpkt
);
596 int attribute_align_arg
avcodec_decode_video2(AVCodecContext
*avctx
, AVFrame
*picture
,
597 int *got_picture_ptr
,
603 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
))
605 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || avpkt
->size
){
606 ret
= avctx
->codec
->decode(avctx
, picture
, got_picture_ptr
,
609 emms_c(); //needed to avoid an emms_c() call before every return;
611 if (*got_picture_ptr
)
612 avctx
->frame_number
++;
619 #if LIBAVCODEC_VERSION_MAJOR < 53
620 int attribute_align_arg
avcodec_decode_audio2(AVCodecContext
*avctx
, int16_t *samples
,
622 const uint8_t *buf
, int buf_size
)
625 av_init_packet(&avpkt
);
627 avpkt
.size
= buf_size
;
629 return avcodec_decode_audio3(avctx
, samples
, frame_size_ptr
, &avpkt
);
633 int attribute_align_arg
avcodec_decode_audio3(AVCodecContext
*avctx
, int16_t *samples
,
639 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || avpkt
->size
){
640 //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
641 if(*frame_size_ptr
< AVCODEC_MAX_AUDIO_FRAME_SIZE
){
642 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
645 if(*frame_size_ptr
< FF_MIN_BUFFER_SIZE
||
646 *frame_size_ptr
< avctx
->channels
* avctx
->frame_size
* sizeof(int16_t)){
647 av_log(avctx
, AV_LOG_ERROR
, "buffer %d too small\n", *frame_size_ptr
);
651 ret
= avctx
->codec
->decode(avctx
, samples
, frame_size_ptr
, avpkt
);
652 avctx
->frame_number
++;
660 #if LIBAVCODEC_VERSION_MAJOR < 53
661 int avcodec_decode_subtitle(AVCodecContext
*avctx
, AVSubtitle
*sub
,
663 const uint8_t *buf
, int buf_size
)
666 av_init_packet(&avpkt
);
668 avpkt
.size
= buf_size
;
670 return avcodec_decode_subtitle2(avctx
, sub
, got_sub_ptr
, &avpkt
);
674 int avcodec_decode_subtitle2(AVCodecContext
*avctx
, AVSubtitle
*sub
,
681 ret
= avctx
->codec
->decode(avctx
, sub
, got_sub_ptr
, avpkt
);
683 avctx
->frame_number
++;
687 av_cold
int avcodec_close(AVCodecContext
*avctx
)
689 /* If there is a user-supplied mutex locking routine, call it. */
691 if ((*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_OBTAIN
))
695 entangled_thread_counter
++;
696 if(entangled_thread_counter
!= 1){
697 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
698 entangled_thread_counter
--;
702 if (HAVE_THREADS
&& avctx
->thread_opaque
)
703 avcodec_thread_free(avctx
);
704 if (avctx
->codec
&& avctx
->codec
->close
)
705 avctx
->codec
->close(avctx
);
706 avcodec_default_free_buffers(avctx
);
707 av_freep(&avctx
->priv_data
);
708 if(avctx
->codec
->encode
)
709 av_freep(&avctx
->extradata
);
711 entangled_thread_counter
--;
713 /* Release any user-supplied mutex. */
715 (*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_RELEASE
);
720 AVCodec
*avcodec_find_encoder(enum CodecID id
)
725 if (p
->encode
!= NULL
&& p
->id
== id
)
732 AVCodec
*avcodec_find_encoder_by_name(const char *name
)
739 if (p
->encode
!= NULL
&& strcmp(name
,p
->name
) == 0)
746 AVCodec
*avcodec_find_decoder(enum CodecID id
)
751 if (p
->decode
!= NULL
&& p
->id
== id
)
758 AVCodec
*avcodec_find_decoder_by_name(const char *name
)
765 if (p
->decode
!= NULL
&& strcmp(name
,p
->name
) == 0)
772 static int get_bit_rate(AVCodecContext
*ctx
)
777 switch(ctx
->codec_type
) {
778 case CODEC_TYPE_VIDEO
:
779 bit_rate
= ctx
->bit_rate
;
781 case CODEC_TYPE_AUDIO
:
782 bits_per_sample
= av_get_bits_per_sample(ctx
->codec_id
);
783 bit_rate
= bits_per_sample ? ctx
->sample_rate
* ctx
->channels
* bits_per_sample
: ctx
->bit_rate
;
785 case CODEC_TYPE_DATA
:
786 bit_rate
= ctx
->bit_rate
;
788 case CODEC_TYPE_SUBTITLE
:
789 bit_rate
= ctx
->bit_rate
;
791 case CODEC_TYPE_ATTACHMENT
:
792 bit_rate
= ctx
->bit_rate
;
801 void avcodec_string(char *buf
, int buf_size
, AVCodecContext
*enc
, int encode
)
803 const char *codec_name
;
807 AVRational display_aspect_ratio
;
810 p
= avcodec_find_encoder(enc
->codec_id
);
812 p
= avcodec_find_decoder(enc
->codec_id
);
815 codec_name
= p
->name
;
816 } else if (enc
->codec_id
== CODEC_ID_MPEG2TS
) {
817 /* fake mpeg2 transport stream codec (currently not
819 codec_name
= "mpeg2ts";
820 } else if (enc
->codec_name
[0] != '\0') {
821 codec_name
= enc
->codec_name
;
823 /* output avi tags */
824 if( isprint(enc
->codec_tag
&0xFF) && isprint((enc
->codec_tag
>>8)&0xFF)
825 && isprint((enc
->codec_tag
>>16)&0xFF) && isprint((enc
->codec_tag
>>24)&0xFF)){
826 snprintf(buf1
, sizeof(buf1
), "%c%c%c%c / 0x%04X",
827 enc
->codec_tag
& 0xff,
828 (enc
->codec_tag
>> 8) & 0xff,
829 (enc
->codec_tag
>> 16) & 0xff,
830 (enc
->codec_tag
>> 24) & 0xff,
833 snprintf(buf1
, sizeof(buf1
), "0x%04x", enc
->codec_tag
);
838 switch(enc
->codec_type
) {
839 case CODEC_TYPE_VIDEO
:
840 snprintf(buf
, buf_size
,
842 codec_name
, enc
->mb_decision ?
" (hq)" : "");
843 if (enc
->pix_fmt
!= PIX_FMT_NONE
) {
844 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
846 avcodec_get_pix_fmt_name(enc
->pix_fmt
));
849 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
851 enc
->width
, enc
->height
);
852 if (enc
->sample_aspect_ratio
.num
) {
853 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
854 enc
->width
*enc
->sample_aspect_ratio
.num
,
855 enc
->height
*enc
->sample_aspect_ratio
.den
,
857 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
858 " [PAR %d:%d DAR %d:%d]",
859 enc
->sample_aspect_ratio
.num
, enc
->sample_aspect_ratio
.den
,
860 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
862 if(av_log_get_level() >= AV_LOG_DEBUG
){
863 int g
= av_gcd(enc
->time_base
.num
, enc
->time_base
.den
);
864 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
866 enc
->time_base
.num
/g
, enc
->time_base
.den
/g
);
870 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
871 ", q=%d-%d", enc
->qmin
, enc
->qmax
);
874 case CODEC_TYPE_AUDIO
:
875 snprintf(buf
, buf_size
,
878 if (enc
->sample_rate
) {
879 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
880 ", %d Hz", enc
->sample_rate
);
882 av_strlcat(buf
, ", ", buf_size
);
883 avcodec_get_channel_layout_string(buf
+ strlen(buf
), buf_size
- strlen(buf
), enc
->channels
, enc
->channel_layout
);
884 if (enc
->sample_fmt
!= SAMPLE_FMT_NONE
) {
885 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
886 ", %s", avcodec_get_sample_fmt_name(enc
->sample_fmt
));
889 case CODEC_TYPE_DATA
:
890 snprintf(buf
, buf_size
, "Data: %s", codec_name
);
892 case CODEC_TYPE_SUBTITLE
:
893 snprintf(buf
, buf_size
, "Subtitle: %s", codec_name
);
895 case CODEC_TYPE_ATTACHMENT
:
896 snprintf(buf
, buf_size
, "Attachment: %s", codec_name
);
899 snprintf(buf
, buf_size
, "Invalid Codec type %d", enc
->codec_type
);
903 if (enc
->flags
& CODEC_FLAG_PASS1
)
904 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
906 if (enc
->flags
& CODEC_FLAG_PASS2
)
907 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
910 bitrate
= get_bit_rate(enc
);
912 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
913 ", %d kb/s", bitrate
/ 1000);
917 unsigned avcodec_version( void )
919 return LIBAVCODEC_VERSION_INT
;
922 const char *avcodec_configuration(void)
924 return FFMPEG_CONFIGURATION
;
927 const char *avcodec_license(void)
929 #define LICENSE_PREFIX "libavcodec license: "
930 return LICENSE_PREFIX FFMPEG_LICENSE
+ sizeof(LICENSE_PREFIX
) - 1;
933 void avcodec_init(void)
935 static int initialized
= 0;
937 if (initialized
!= 0)
941 dsputil_static_init();
944 void avcodec_flush_buffers(AVCodecContext
*avctx
)
946 if(avctx
->codec
->flush
)
947 avctx
->codec
->flush(avctx
);
950 void avcodec_default_free_buffers(AVCodecContext
*s
){
953 if(s
->internal_buffer
==NULL
) return;
955 if (s
->internal_buffer_count
)
956 av_log(s
, AV_LOG_WARNING
, "Found %i unreleased buffers!\n", s
->internal_buffer_count
);
957 for(i
=0; i
<INTERNAL_BUFFER_SIZE
; i
++){
958 InternalBuffer
*buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
960 av_freep(&buf
->base
[j
]);
964 av_freep(&s
->internal_buffer
);
966 s
->internal_buffer_count
=0;
969 char av_get_pict_type_char(int pict_type
){
971 case FF_I_TYPE
: return 'I';
972 case FF_P_TYPE
: return 'P';
973 case FF_B_TYPE
: return 'B';
974 case FF_S_TYPE
: return 'S';
975 case FF_SI_TYPE
:return 'i';
976 case FF_SP_TYPE
:return 'p';
977 case FF_BI_TYPE
:return 'b';
982 int av_get_bits_per_sample(enum CodecID codec_id
){
984 case CODEC_ID_ADPCM_SBPRO_2
:
986 case CODEC_ID_ADPCM_SBPRO_3
:
988 case CODEC_ID_ADPCM_SBPRO_4
:
989 case CODEC_ID_ADPCM_CT
:
990 case CODEC_ID_ADPCM_IMA_WAV
:
991 case CODEC_ID_ADPCM_MS
:
992 case CODEC_ID_ADPCM_YAMAHA
:
994 case CODEC_ID_PCM_ALAW
:
995 case CODEC_ID_PCM_MULAW
:
996 case CODEC_ID_PCM_S8
:
997 case CODEC_ID_PCM_U8
:
998 case CODEC_ID_PCM_ZORK
:
1000 case CODEC_ID_PCM_S16BE
:
1001 case CODEC_ID_PCM_S16LE
:
1002 case CODEC_ID_PCM_S16LE_PLANAR
:
1003 case CODEC_ID_PCM_U16BE
:
1004 case CODEC_ID_PCM_U16LE
:
1006 case CODEC_ID_PCM_S24DAUD
:
1007 case CODEC_ID_PCM_S24BE
:
1008 case CODEC_ID_PCM_S24LE
:
1009 case CODEC_ID_PCM_U24BE
:
1010 case CODEC_ID_PCM_U24LE
:
1012 case CODEC_ID_PCM_S32BE
:
1013 case CODEC_ID_PCM_S32LE
:
1014 case CODEC_ID_PCM_U32BE
:
1015 case CODEC_ID_PCM_U32LE
:
1016 case CODEC_ID_PCM_F32BE
:
1017 case CODEC_ID_PCM_F32LE
:
1019 case CODEC_ID_PCM_F64BE
:
1020 case CODEC_ID_PCM_F64LE
:
1027 int av_get_bits_per_sample_format(enum SampleFormat sample_fmt
) {
1028 switch (sample_fmt
) {
1031 case SAMPLE_FMT_S16
:
1033 case SAMPLE_FMT_S32
:
1034 case SAMPLE_FMT_FLT
:
1036 case SAMPLE_FMT_DBL
:
1044 int avcodec_thread_init(AVCodecContext
*s
, int thread_count
){
1045 s
->thread_count
= thread_count
;
1050 unsigned int av_xiphlacing(unsigned char *s
, unsigned int v
)
1064 /* Wrapper to work around the lack of mkstemp() on mingw/cygin.
1065 * Also, tries to create file in /tmp first, if possible.
1066 * *prefix can be a character constant; *filename will be allocated internally.
1067 * Returns file descriptor of opened file (or -1 on error)
1068 * and opened file name in **filename. */
1069 int av_tempfile(char *prefix
, char **filename
) {
1072 *filename
= tempnam(".", prefix
);
1074 size_t len
= strlen(prefix
) + 12; /* room for "/tmp/" and "XXXXXX\0" */
1075 *filename
= av_malloc(len
);
1077 /* -----common section-----*/
1078 if (*filename
== NULL
) {
1079 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot allocate file name\n");
1083 fd
= open(*filename
, O_RDWR
| O_BINARY
| O_CREAT
, 0444);
1085 snprintf(*filename
, len
, "/tmp/%sXXXXXX", prefix
);
1086 fd
= mkstemp(*filename
);
1088 snprintf(*filename
, len
, "./%sXXXXXX", prefix
);
1089 fd
= mkstemp(*filename
);
1092 /* -----common section-----*/
1094 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot open temporary file %s\n", *filename
);
1097 return fd
; /* success */
1103 } VideoFrameSizeAbbr
;
1107 int rate_num
, rate_den
;
1108 } VideoFrameRateAbbr
;
1110 static const VideoFrameSizeAbbr video_frame_size_abbrs
[] = {
1111 { "ntsc", 720, 480 },
1112 { "pal", 720, 576 },
1113 { "qntsc", 352, 240 }, /* VCD compliant NTSC */
1114 { "qpal", 352, 288 }, /* VCD compliant PAL */
1115 { "sntsc", 640, 480 }, /* square pixel NTSC */
1116 { "spal", 768, 576 }, /* square pixel PAL */
1117 { "film", 352, 240 },
1118 { "ntsc-film", 352, 240 },
1119 { "sqcif", 128, 96 },
1120 { "qcif", 176, 144 },
1121 { "cif", 352, 288 },
1122 { "4cif", 704, 576 },
1123 { "16cif", 1408,1152 },
1124 { "qqvga", 160, 120 },
1125 { "qvga", 320, 240 },
1126 { "vga", 640, 480 },
1127 { "svga", 800, 600 },
1128 { "xga", 1024, 768 },
1129 { "uxga", 1600,1200 },
1130 { "qxga", 2048,1536 },
1131 { "sxga", 1280,1024 },
1132 { "qsxga", 2560,2048 },
1133 { "hsxga", 5120,4096 },
1134 { "wvga", 852, 480 },
1135 { "wxga", 1366, 768 },
1136 { "wsxga", 1600,1024 },
1137 { "wuxga", 1920,1200 },
1138 { "woxga", 2560,1600 },
1139 { "wqsxga", 3200,2048 },
1140 { "wquxga", 3840,2400 },
1141 { "whsxga", 6400,4096 },
1142 { "whuxga", 7680,4800 },
1143 { "cga", 320, 200 },
1144 { "ega", 640, 350 },
1145 { "hd480", 852, 480 },
1146 { "hd720", 1280, 720 },
1147 { "hd1080", 1920,1080 },
1150 static const VideoFrameRateAbbr video_frame_rate_abbrs
[]= {
1151 { "ntsc", 30000, 1001 },
1153 { "qntsc", 30000, 1001 }, /* VCD compliant NTSC */
1154 { "qpal", 25, 1 }, /* VCD compliant PAL */
1155 { "sntsc", 30000, 1001 }, /* square pixel NTSC */
1156 { "spal", 25, 1 }, /* square pixel PAL */
1158 { "ntsc-film", 24000, 1001 },
1161 int av_parse_video_frame_size(int *width_ptr
, int *height_ptr
, const char *str
)
1164 int n
= FF_ARRAY_ELEMS(video_frame_size_abbrs
);
1166 int frame_width
= 0, frame_height
= 0;
1169 if (!strcmp(video_frame_size_abbrs
[i
].abbr
, str
)) {
1170 frame_width
= video_frame_size_abbrs
[i
].width
;
1171 frame_height
= video_frame_size_abbrs
[i
].height
;
1177 frame_width
= strtol(p
, &p
, 10);
1180 frame_height
= strtol(p
, &p
, 10);
1182 if (frame_width
<= 0 || frame_height
<= 0)
1184 *width_ptr
= frame_width
;
1185 *height_ptr
= frame_height
;
1189 int av_parse_video_frame_rate(AVRational
*frame_rate
, const char *arg
)
1192 int n
= FF_ARRAY_ELEMS(video_frame_rate_abbrs
);
1195 /* First, we check our abbreviation table */
1196 for (i
= 0; i
< n
; ++i
)
1197 if (!strcmp(video_frame_rate_abbrs
[i
].abbr
, arg
)) {
1198 frame_rate
->num
= video_frame_rate_abbrs
[i
].rate_num
;
1199 frame_rate
->den
= video_frame_rate_abbrs
[i
].rate_den
;
1203 /* Then, we try to parse it as fraction */
1204 cp
= strchr(arg
, '/');
1206 cp
= strchr(arg
, ':');
1209 frame_rate
->num
= strtol(arg
, &cpp
, 10);
1210 if (cpp
!= arg
|| cpp
== cp
)
1211 frame_rate
->den
= strtol(cp
+1, &cpp
, 10);
1213 frame_rate
->num
= 0;
1216 /* Finally we give up and parse it as double */
1217 AVRational time_base
= av_d2q(strtod(arg
, 0), 1001000);
1218 frame_rate
->den
= time_base
.den
;
1219 frame_rate
->num
= time_base
.num
;
1221 if (!frame_rate
->num
|| !frame_rate
->den
)
1227 int ff_match_2uint16(const uint16_t (*tab
)[2], int size
, int a
, int b
){
1229 for(i
=0; i
<size
&& !(tab
[i
][0]==a
&& tab
[i
][1]==b
); i
++);
1233 void av_log_missing_feature(void *avc
, const char *feature
, int want_sample
)
1235 av_log(avc
, AV_LOG_WARNING
, "%s not implemented. Update your FFmpeg "
1236 "version to the newest one from SVN. If the problem still "
1237 "occurs, it means that your file has a feature which has not "
1238 "been implemented.", feature
);
1240 av_log_ask_for_sample(avc
, NULL
);
1242 av_log(avc
, AV_LOG_WARNING
, "\n");
1245 void av_log_ask_for_sample(void *avc
, const char *msg
)
1248 av_log(avc
, AV_LOG_WARNING
, "%s ", msg
);
1249 av_log(avc
, AV_LOG_WARNING
, "If you want to help, upload a sample "
1250 "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
1251 "and contact the ffmpeg-devel mailing list.\n");
1254 static AVHWAccel
*first_hwaccel
= NULL
;
1256 void av_register_hwaccel(AVHWAccel
*hwaccel
)
1258 AVHWAccel
**p
= &first_hwaccel
;
1262 hwaccel
->next
= NULL
;
1265 AVHWAccel
*av_hwaccel_next(AVHWAccel
*hwaccel
)
1267 return hwaccel ? hwaccel
->next
: first_hwaccel
;
1270 AVHWAccel
*ff_find_hwaccel(enum CodecID codec_id
, enum PixelFormat pix_fmt
)
1272 AVHWAccel
*hwaccel
=NULL
;
1274 while((hwaccel
= av_hwaccel_next(hwaccel
))){
1275 if ( hwaccel
->id
== codec_id
1276 && hwaccel
->pix_fmt
== pix_fmt
)
1282 int av_lockmgr_register(int (*cb
)(void **mutex
, enum AVLockOp op
))
1284 if (ff_lockmgr_cb
) {
1285 if (ff_lockmgr_cb(&codec_mutex
, AV_LOCK_DESTROY
))
1291 if (ff_lockmgr_cb
) {
1292 if (ff_lockmgr_cb(&codec_mutex
, AV_LOCK_CREATE
))