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"
37 #include "imgconvert.h"
38 #include "audioconvert.h"
48 const uint8_t ff_reverse
[256]={
49 0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
50 0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
51 0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
52 0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
53 0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
54 0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
55 0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
56 0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
57 0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
58 0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
59 0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
60 0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
61 0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
62 0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
63 0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
64 0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
67 static int volatile entangled_thread_counter
=0;
69 void *av_fast_realloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
74 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
76 ptr
= av_realloc(ptr
, *size
);
77 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
83 void av_fast_malloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
88 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
90 *p
= av_malloc(*size
);
94 /* encoder management */
95 static AVCodec
*first_avcodec
= NULL
;
97 AVCodec
*av_codec_next(AVCodec
*c
){
99 else return first_avcodec
;
102 void avcodec_register(AVCodec
*codec
)
107 while (*p
!= NULL
) p
= &(*p
)->next
;
112 #if LIBAVCODEC_VERSION_MAJOR < 53
113 void register_avcodec(AVCodec
*codec
)
115 avcodec_register(codec
);
119 void avcodec_set_dimensions(AVCodecContext
*s
, int width
, int height
){
120 s
->coded_width
= width
;
121 s
->coded_height
= height
;
122 s
->width
= -((-width
)>>s
->lowres
);
123 s
->height
= -((-height
)>>s
->lowres
);
126 typedef struct InternalBuffer
{
132 enum PixelFormat pix_fmt
;
135 #define INTERNAL_BUFFER_SIZE 32
137 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
139 void avcodec_align_dimensions(AVCodecContext
*s
, int *width
, int *height
){
144 case PIX_FMT_YUV420P
:
145 case PIX_FMT_YUYV422
:
146 case PIX_FMT_UYVY422
:
147 case PIX_FMT_YUV422P
:
148 case PIX_FMT_YUV444P
:
150 case PIX_FMT_GRAY16BE
:
151 case PIX_FMT_GRAY16LE
:
152 case PIX_FMT_YUVJ420P
:
153 case PIX_FMT_YUVJ422P
:
154 case PIX_FMT_YUVJ444P
:
155 case PIX_FMT_YUVA420P
:
156 w_align
= 16; //FIXME check for non mpeg style codecs and use less alignment
158 if(s
->codec_id
== CODEC_ID_MPEG2VIDEO
)
159 h_align
= 32; // interlaced is rounded up to 2 MBs
161 case PIX_FMT_YUV411P
:
162 case PIX_FMT_UYYVYY411
:
166 case PIX_FMT_YUV410P
:
167 if(s
->codec_id
== CODEC_ID_SVQ1
){
172 if(s
->codec_id
== CODEC_ID_RPZA
){
179 if(s
->codec_id
== CODEC_ID_SMC
){
185 if((s
->codec_id
== CODEC_ID_MSZH
) || (s
->codec_id
== CODEC_ID_ZLIB
)){
196 *width
= ALIGN(*width
, w_align
);
197 *height
= ALIGN(*height
, h_align
);
198 if(s
->codec_id
== CODEC_ID_H264
)
199 *height
+=2; // some of the optimized chroma MC reads one line too much
202 int avcodec_check_dimensions(void *av_log_ctx
, unsigned int w
, unsigned int h
){
203 if((int)w
>0 && (int)h
>0 && (w
+128)*(uint64_t)(h
+128) < INT_MAX
/4)
206 av_log(av_log_ctx
, AV_LOG_ERROR
, "picture size invalid (%ux%u)\n", w
, h
);
210 int avcodec_default_get_buffer(AVCodecContext
*s
, AVFrame
*pic
){
217 if(pic
->data
[0]!=NULL
) {
218 av_log(s
, AV_LOG_ERROR
, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
221 if(s
->internal_buffer_count
>= INTERNAL_BUFFER_SIZE
) {
222 av_log(s
, AV_LOG_ERROR
, "internal_buffer_count overflow (missing release_buffer?)\n");
226 if(avcodec_check_dimensions(s
,w
,h
))
229 if(s
->internal_buffer
==NULL
){
230 s
->internal_buffer
= av_mallocz((INTERNAL_BUFFER_SIZE
+1)*sizeof(InternalBuffer
));
233 s
->internal_buffer
= av_fast_realloc(
235 &s
->internal_buffer_size
,
236 sizeof(InternalBuffer
)*FFMAX(99, s
->internal_buffer_count
+1)/*FIXME*/
240 buf
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
241 picture_number
= &(((InternalBuffer
*)s
->internal_buffer
)[INTERNAL_BUFFER_SIZE
]).last_pic_num
; //FIXME ugly hack
244 if(buf
->base
[0] && (buf
->width
!= w
|| buf
->height
!= h
|| buf
->pix_fmt
!= s
->pix_fmt
)){
246 av_freep(&buf
->base
[i
]);
252 pic
->age
= *picture_number
- buf
->last_pic_num
;
253 buf
->last_pic_num
= *picture_number
;
255 int h_chroma_shift
, v_chroma_shift
;
262 avcodec_get_chroma_sub_sample(s
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
264 avcodec_align_dimensions(s
, &w
, &h
);
266 if(!(s
->flags
&CODEC_FLAG_EMU_EDGE
)){
272 // NOTE: do not align linesizes individually, this breaks e.g. assumptions
273 // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
274 ff_fill_linesize(&picture
, s
->pix_fmt
, w
);
275 // increase alignment of w for next try (rhs gives the lowest bit set in w)
280 //STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
281 //we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
282 //picture size unneccessarily in some cases. The solution here is not
283 //pretty and better ideas are welcome!
285 if(s
->codec_id
== CODEC_ID_SVQ1
)
289 stride_align
[i
] = STRIDE_ALIGN
;
290 unaligned
|= picture
.linesize
[i
] % stride_align
[i
];
294 tmpsize
= ff_fill_pointer(&picture
, NULL
, s
->pix_fmt
, h
);
298 for (i
=0; i
<3 && picture
.data
[i
+1]; i
++)
299 size
[i
] = picture
.data
[i
+1] - picture
.data
[i
];
300 size
[i
] = tmpsize
- (picture
.data
[i
] - picture
.data
[0]);
302 buf
->last_pic_num
= -256*256*256*64;
303 memset(buf
->base
, 0, sizeof(buf
->base
));
304 memset(buf
->data
, 0, sizeof(buf
->data
));
306 for(i
=0; i
<4 && size
[i
]; i
++){
307 const int h_shift
= i
==0 ? 0 : h_chroma_shift
;
308 const int v_shift
= i
==0 ? 0 : v_chroma_shift
;
310 buf
->linesize
[i
]= picture
.linesize
[i
];
312 buf
->base
[i
]= av_malloc(size
[i
]+16); //FIXME 16
313 if(buf
->base
[i
]==NULL
) return -1;
314 memset(buf
->base
[i
], 128, size
[i
]);
316 // no edge if EDEG EMU or not planar YUV
317 if((s
->flags
&CODEC_FLAG_EMU_EDGE
) || !size
[2])
318 buf
->data
[i
] = buf
->base
[i
];
320 buf
->data
[i
] = buf
->base
[i
] + ALIGN((buf
->linesize
[i
]*EDGE_WIDTH
>>v_shift
) + (EDGE_WIDTH
>>h_shift
), stride_align
[i
]);
322 if(size
[1] && !size
[2])
323 ff_set_systematic_pal((uint32_t*)buf
->data
[1], s
->pix_fmt
);
324 buf
->width
= s
->width
;
325 buf
->height
= s
->height
;
326 buf
->pix_fmt
= s
->pix_fmt
;
327 pic
->age
= 256*256*256*64;
329 pic
->type
= FF_BUFFER_TYPE_INTERNAL
;
332 pic
->base
[i
]= buf
->base
[i
];
333 pic
->data
[i
]= buf
->data
[i
];
334 pic
->linesize
[i
]= buf
->linesize
[i
];
336 s
->internal_buffer_count
++;
338 pic
->reordered_opaque
= s
->reordered_opaque
;
340 if(s
->debug
&FF_DEBUG_BUFFERS
)
341 av_log(s
, AV_LOG_DEBUG
, "default_get_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
346 void avcodec_default_release_buffer(AVCodecContext
*s
, AVFrame
*pic
){
348 InternalBuffer
*buf
, *last
;
350 assert(pic
->type
==FF_BUFFER_TYPE_INTERNAL
);
351 assert(s
->internal_buffer_count
);
353 buf
= NULL
; /* avoids warning */
354 for(i
=0; i
<s
->internal_buffer_count
; i
++){ //just 3-5 checks so is not worth to optimize
355 buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
356 if(buf
->data
[0] == pic
->data
[0])
359 assert(i
< s
->internal_buffer_count
);
360 s
->internal_buffer_count
--;
361 last
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
363 FFSWAP(InternalBuffer
, *buf
, *last
);
367 // pic->base[i]=NULL;
369 //printf("R%X\n", pic->opaque);
371 if(s
->debug
&FF_DEBUG_BUFFERS
)
372 av_log(s
, AV_LOG_DEBUG
, "default_release_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
375 int avcodec_default_reget_buffer(AVCodecContext
*s
, AVFrame
*pic
){
379 /* If no picture return a new buffer */
380 if(pic
->data
[0] == NULL
) {
381 /* We will copy from buffer, so must be readable */
382 pic
->buffer_hints
|= FF_BUFFER_HINTS_READABLE
;
383 return s
->get_buffer(s
, pic
);
386 /* If internal buffer type return the same buffer */
387 if(pic
->type
== FF_BUFFER_TYPE_INTERNAL
)
391 * Not internal type and reget_buffer not overridden, emulate cr buffer
394 for(i
= 0; i
< 4; i
++)
395 pic
->data
[i
] = pic
->base
[i
] = NULL
;
397 /* Allocate new frame */
398 if (s
->get_buffer(s
, pic
))
400 /* Copy image data from old buffer to new buffer */
401 av_picture_copy((AVPicture
*)pic
, (AVPicture
*)&temp_pic
, s
->pix_fmt
, s
->width
,
403 s
->release_buffer(s
, &temp_pic
); // Release old frame
407 int avcodec_default_execute(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
),void *arg
, int *ret
, int count
, int size
){
410 for(i
=0; i
<count
; i
++){
411 int r
= func(c
, (char*)arg
+ i
*size
);
417 enum PixelFormat
avcodec_default_get_format(struct AVCodecContext
*s
, const enum PixelFormat
*fmt
){
418 while (*fmt
!= PIX_FMT_NONE
&& ff_is_hwaccel_pix_fmt(*fmt
))
423 void avcodec_get_frame_defaults(AVFrame
*pic
){
424 memset(pic
, 0, sizeof(AVFrame
));
426 pic
->pts
= AV_NOPTS_VALUE
;
430 AVFrame
*avcodec_alloc_frame(void){
431 AVFrame
*pic
= av_malloc(sizeof(AVFrame
));
433 if(pic
==NULL
) return NULL
;
435 avcodec_get_frame_defaults(pic
);
440 int attribute_align_arg
avcodec_open(AVCodecContext
*avctx
, AVCodec
*codec
)
444 entangled_thread_counter
++;
445 if(entangled_thread_counter
!= 1){
446 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
450 if(avctx
->codec
|| !codec
)
453 if (codec
->priv_data_size
> 0) {
454 avctx
->priv_data
= av_mallocz(codec
->priv_data_size
);
455 if (!avctx
->priv_data
) {
456 ret
= AVERROR(ENOMEM
);
460 avctx
->priv_data
= NULL
;
463 if(avctx
->coded_width
&& avctx
->coded_height
)
464 avcodec_set_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
);
465 else if(avctx
->width
&& avctx
->height
)
466 avcodec_set_dimensions(avctx
, avctx
->width
, avctx
->height
);
468 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
)){
469 av_freep(&avctx
->priv_data
);
470 ret
= AVERROR(EINVAL
);
474 avctx
->codec
= codec
;
475 avctx
->codec_id
= codec
->id
;
476 avctx
->frame_number
= 0;
477 if(avctx
->codec
->init
){
478 ret
= avctx
->codec
->init(avctx
);
480 av_freep(&avctx
->priv_data
);
487 entangled_thread_counter
--;
491 int attribute_align_arg
avcodec_encode_audio(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
492 const short *samples
)
494 if(buf_size
< FF_MIN_BUFFER_SIZE
&& 0){
495 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
498 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || samples
){
499 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, samples
);
500 avctx
->frame_number
++;
506 int attribute_align_arg
avcodec_encode_video(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
509 if(buf_size
< FF_MIN_BUFFER_SIZE
){
510 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
513 if(avcodec_check_dimensions(avctx
,avctx
->width
,avctx
->height
))
515 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || pict
){
516 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, pict
);
517 avctx
->frame_number
++;
518 emms_c(); //needed to avoid an emms_c() call before every return;
525 int avcodec_encode_subtitle(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
526 const AVSubtitle
*sub
)
529 if(sub
->start_display_time
) {
530 av_log(avctx
, AV_LOG_ERROR
, "start_display_time must be 0.\n");
533 if(sub
->num_rects
== 0 || !sub
->rects
)
535 ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, sub
);
536 avctx
->frame_number
++;
540 #if LIBAVCODEC_VERSION_MAJOR < 53
541 int attribute_align_arg
avcodec_decode_video(AVCodecContext
*avctx
, AVFrame
*picture
,
542 int *got_picture_ptr
,
543 const uint8_t *buf
, int buf_size
)
546 av_init_packet(&avpkt
);
548 avpkt
.size
= buf_size
;
550 return avcodec_decode_video2(avctx
, picture
, got_picture_ptr
, &avpkt
);
554 int attribute_align_arg
avcodec_decode_video2(AVCodecContext
*avctx
, AVFrame
*picture
,
555 int *got_picture_ptr
,
561 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
))
563 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || avpkt
->size
){
564 ret
= avctx
->codec
->decode(avctx
, picture
, got_picture_ptr
,
567 emms_c(); //needed to avoid an emms_c() call before every return;
569 if (*got_picture_ptr
)
570 avctx
->frame_number
++;
577 #if LIBAVCODEC_VERSION_MAJOR < 53
578 int attribute_align_arg
avcodec_decode_audio2(AVCodecContext
*avctx
, int16_t *samples
,
580 const uint8_t *buf
, int buf_size
)
583 av_init_packet(&avpkt
);
585 avpkt
.size
= buf_size
;
587 return avcodec_decode_audio3(avctx
, samples
, frame_size_ptr
, &avpkt
);
591 int attribute_align_arg
avcodec_decode_audio3(AVCodecContext
*avctx
, int16_t *samples
,
597 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || avpkt
->size
){
598 //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
599 if(*frame_size_ptr
< AVCODEC_MAX_AUDIO_FRAME_SIZE
){
600 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
603 if(*frame_size_ptr
< FF_MIN_BUFFER_SIZE
||
604 *frame_size_ptr
< avctx
->channels
* avctx
->frame_size
* sizeof(int16_t)){
605 av_log(avctx
, AV_LOG_ERROR
, "buffer %d too small\n", *frame_size_ptr
);
609 ret
= avctx
->codec
->decode(avctx
, samples
, frame_size_ptr
, avpkt
);
610 avctx
->frame_number
++;
618 #if LIBAVCODEC_VERSION_MAJOR < 53
619 int avcodec_decode_subtitle(AVCodecContext
*avctx
, AVSubtitle
*sub
,
621 const uint8_t *buf
, int buf_size
)
624 av_init_packet(&avpkt
);
626 avpkt
.size
= buf_size
;
628 return avcodec_decode_subtitle2(avctx
, sub
, got_sub_ptr
, &avpkt
);
632 int avcodec_decode_subtitle2(AVCodecContext
*avctx
, AVSubtitle
*sub
,
639 ret
= avctx
->codec
->decode(avctx
, sub
, got_sub_ptr
, avpkt
);
641 avctx
->frame_number
++;
645 int avcodec_close(AVCodecContext
*avctx
)
647 entangled_thread_counter
++;
648 if(entangled_thread_counter
!= 1){
649 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
650 entangled_thread_counter
--;
654 if (HAVE_THREADS
&& avctx
->thread_opaque
)
655 avcodec_thread_free(avctx
);
656 if (avctx
->codec
->close
)
657 avctx
->codec
->close(avctx
);
658 avcodec_default_free_buffers(avctx
);
659 av_freep(&avctx
->priv_data
);
661 entangled_thread_counter
--;
665 AVCodec
*avcodec_find_encoder(enum CodecID id
)
670 if (p
->encode
!= NULL
&& p
->id
== id
)
677 AVCodec
*avcodec_find_encoder_by_name(const char *name
)
684 if (p
->encode
!= NULL
&& strcmp(name
,p
->name
) == 0)
691 AVCodec
*avcodec_find_decoder(enum CodecID id
)
696 if (p
->decode
!= NULL
&& p
->id
== id
)
703 AVCodec
*avcodec_find_decoder_by_name(const char *name
)
710 if (p
->decode
!= NULL
&& strcmp(name
,p
->name
) == 0)
717 void avcodec_string(char *buf
, int buf_size
, AVCodecContext
*enc
, int encode
)
719 const char *codec_name
;
723 AVRational display_aspect_ratio
;
726 p
= avcodec_find_encoder(enc
->codec_id
);
728 p
= avcodec_find_decoder(enc
->codec_id
);
731 codec_name
= p
->name
;
732 } else if (enc
->codec_id
== CODEC_ID_MPEG2TS
) {
733 /* fake mpeg2 transport stream codec (currently not
735 codec_name
= "mpeg2ts";
736 } else if (enc
->codec_name
[0] != '\0') {
737 codec_name
= enc
->codec_name
;
739 /* output avi tags */
740 if( isprint(enc
->codec_tag
&0xFF) && isprint((enc
->codec_tag
>>8)&0xFF)
741 && isprint((enc
->codec_tag
>>16)&0xFF) && isprint((enc
->codec_tag
>>24)&0xFF)){
742 snprintf(buf1
, sizeof(buf1
), "%c%c%c%c / 0x%04X",
743 enc
->codec_tag
& 0xff,
744 (enc
->codec_tag
>> 8) & 0xff,
745 (enc
->codec_tag
>> 16) & 0xff,
746 (enc
->codec_tag
>> 24) & 0xff,
749 snprintf(buf1
, sizeof(buf1
), "0x%04x", enc
->codec_tag
);
754 switch(enc
->codec_type
) {
755 case CODEC_TYPE_VIDEO
:
756 snprintf(buf
, buf_size
,
758 codec_name
, enc
->mb_decision
? " (hq)" : "");
759 if (enc
->pix_fmt
!= PIX_FMT_NONE
) {
760 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
762 avcodec_get_pix_fmt_name(enc
->pix_fmt
));
765 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
767 enc
->width
, enc
->height
);
768 if (enc
->sample_aspect_ratio
.num
) {
769 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
770 enc
->width
*enc
->sample_aspect_ratio
.num
,
771 enc
->height
*enc
->sample_aspect_ratio
.den
,
773 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
774 " [PAR %d:%d DAR %d:%d]",
775 enc
->sample_aspect_ratio
.num
, enc
->sample_aspect_ratio
.den
,
776 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
778 if(av_log_get_level() >= AV_LOG_DEBUG
){
779 int g
= av_gcd(enc
->time_base
.num
, enc
->time_base
.den
);
780 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
782 enc
->time_base
.num
/g
, enc
->time_base
.den
/g
);
786 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
787 ", q=%d-%d", enc
->qmin
, enc
->qmax
);
789 bitrate
= enc
->bit_rate
;
791 case CODEC_TYPE_AUDIO
:
792 snprintf(buf
, buf_size
,
795 if (enc
->sample_rate
) {
796 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
797 ", %d Hz", enc
->sample_rate
);
799 av_strlcat(buf
, ", ", buf_size
);
800 avcodec_get_channel_layout_string(buf
+ strlen(buf
), buf_size
- strlen(buf
), enc
->channels
, enc
->channel_layout
);
801 if (enc
->sample_fmt
!= SAMPLE_FMT_NONE
) {
802 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
803 ", %s", avcodec_get_sample_fmt_name(enc
->sample_fmt
));
806 /* for PCM codecs, compute bitrate directly */
807 switch(enc
->codec_id
) {
808 case CODEC_ID_PCM_F64BE
:
809 case CODEC_ID_PCM_F64LE
:
810 bitrate
= enc
->sample_rate
* enc
->channels
* 64;
812 case CODEC_ID_PCM_S32LE
:
813 case CODEC_ID_PCM_S32BE
:
814 case CODEC_ID_PCM_U32LE
:
815 case CODEC_ID_PCM_U32BE
:
816 case CODEC_ID_PCM_F32BE
:
817 case CODEC_ID_PCM_F32LE
:
818 bitrate
= enc
->sample_rate
* enc
->channels
* 32;
820 case CODEC_ID_PCM_S24LE
:
821 case CODEC_ID_PCM_S24BE
:
822 case CODEC_ID_PCM_U24LE
:
823 case CODEC_ID_PCM_U24BE
:
824 case CODEC_ID_PCM_S24DAUD
:
825 bitrate
= enc
->sample_rate
* enc
->channels
* 24;
827 case CODEC_ID_PCM_S16LE
:
828 case CODEC_ID_PCM_S16BE
:
829 case CODEC_ID_PCM_S16LE_PLANAR
:
830 case CODEC_ID_PCM_U16LE
:
831 case CODEC_ID_PCM_U16BE
:
832 bitrate
= enc
->sample_rate
* enc
->channels
* 16;
834 case CODEC_ID_PCM_S8
:
835 case CODEC_ID_PCM_U8
:
836 case CODEC_ID_PCM_ALAW
:
837 case CODEC_ID_PCM_MULAW
:
838 case CODEC_ID_PCM_ZORK
:
839 bitrate
= enc
->sample_rate
* enc
->channels
* 8;
842 bitrate
= enc
->bit_rate
;
846 case CODEC_TYPE_DATA
:
847 snprintf(buf
, buf_size
, "Data: %s", codec_name
);
848 bitrate
= enc
->bit_rate
;
850 case CODEC_TYPE_SUBTITLE
:
851 snprintf(buf
, buf_size
, "Subtitle: %s", codec_name
);
852 bitrate
= enc
->bit_rate
;
854 case CODEC_TYPE_ATTACHMENT
:
855 snprintf(buf
, buf_size
, "Attachment: %s", codec_name
);
856 bitrate
= enc
->bit_rate
;
859 snprintf(buf
, buf_size
, "Invalid Codec type %d", enc
->codec_type
);
863 if (enc
->flags
& CODEC_FLAG_PASS1
)
864 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
866 if (enc
->flags
& CODEC_FLAG_PASS2
)
867 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
871 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
872 ", %d kb/s", bitrate
/ 1000);
876 unsigned avcodec_version( void )
878 return LIBAVCODEC_VERSION_INT
;
881 void avcodec_init(void)
883 static int initialized
= 0;
885 if (initialized
!= 0)
889 dsputil_static_init();
892 void avcodec_flush_buffers(AVCodecContext
*avctx
)
894 if(avctx
->codec
->flush
)
895 avctx
->codec
->flush(avctx
);
898 void avcodec_default_free_buffers(AVCodecContext
*s
){
901 if(s
->internal_buffer
==NULL
) return;
903 for(i
=0; i
<INTERNAL_BUFFER_SIZE
; i
++){
904 InternalBuffer
*buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
906 av_freep(&buf
->base
[j
]);
910 av_freep(&s
->internal_buffer
);
912 s
->internal_buffer_count
=0;
915 char av_get_pict_type_char(int pict_type
){
917 case FF_I_TYPE
: return 'I';
918 case FF_P_TYPE
: return 'P';
919 case FF_B_TYPE
: return 'B';
920 case FF_S_TYPE
: return 'S';
921 case FF_SI_TYPE
:return 'i';
922 case FF_SP_TYPE
:return 'p';
923 case FF_BI_TYPE
:return 'b';
928 int av_get_bits_per_sample(enum CodecID codec_id
){
930 case CODEC_ID_ADPCM_SBPRO_2
:
932 case CODEC_ID_ADPCM_SBPRO_3
:
934 case CODEC_ID_ADPCM_SBPRO_4
:
935 case CODEC_ID_ADPCM_CT
:
937 case CODEC_ID_PCM_ALAW
:
938 case CODEC_ID_PCM_MULAW
:
939 case CODEC_ID_PCM_S8
:
940 case CODEC_ID_PCM_U8
:
941 case CODEC_ID_PCM_ZORK
:
943 case CODEC_ID_PCM_S16BE
:
944 case CODEC_ID_PCM_S16LE
:
945 case CODEC_ID_PCM_S16LE_PLANAR
:
946 case CODEC_ID_PCM_U16BE
:
947 case CODEC_ID_PCM_U16LE
:
949 case CODEC_ID_PCM_S24DAUD
:
950 case CODEC_ID_PCM_S24BE
:
951 case CODEC_ID_PCM_S24LE
:
952 case CODEC_ID_PCM_U24BE
:
953 case CODEC_ID_PCM_U24LE
:
955 case CODEC_ID_PCM_S32BE
:
956 case CODEC_ID_PCM_S32LE
:
957 case CODEC_ID_PCM_U32BE
:
958 case CODEC_ID_PCM_U32LE
:
959 case CODEC_ID_PCM_F32BE
:
960 case CODEC_ID_PCM_F32LE
:
962 case CODEC_ID_PCM_F64BE
:
963 case CODEC_ID_PCM_F64LE
:
970 int av_get_bits_per_sample_format(enum SampleFormat sample_fmt
) {
971 switch (sample_fmt
) {
987 int avcodec_thread_init(AVCodecContext
*s
, int thread_count
){
992 unsigned int av_xiphlacing(unsigned char *s
, unsigned int v
)
1006 /* Wrapper to work around the lack of mkstemp() on mingw/cygin.
1007 * Also, tries to create file in /tmp first, if possible.
1008 * *prefix can be a character constant; *filename will be allocated internally.
1009 * Returns file descriptor of opened file (or -1 on error)
1010 * and opened file name in **filename. */
1011 int av_tempfile(char *prefix
, char **filename
) {
1014 *filename
= tempnam(".", prefix
);
1016 size_t len
= strlen(prefix
) + 12; /* room for "/tmp/" and "XXXXXX\0" */
1017 *filename
= av_malloc(len
);
1019 /* -----common section-----*/
1020 if (*filename
== NULL
) {
1021 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot allocate file name\n");
1025 fd
= open(*filename
, O_RDWR
| O_BINARY
| O_CREAT
, 0444);
1027 snprintf(*filename
, len
, "/tmp/%sXXXXXX", prefix
);
1028 fd
= mkstemp(*filename
);
1030 snprintf(*filename
, len
, "./%sXXXXXX", prefix
);
1031 fd
= mkstemp(*filename
);
1034 /* -----common section-----*/
1036 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot open temporary file %s\n", *filename
);
1039 return fd
; /* success */
1045 } VideoFrameSizeAbbr
;
1049 int rate_num
, rate_den
;
1050 } VideoFrameRateAbbr
;
1052 static const VideoFrameSizeAbbr video_frame_size_abbrs
[] = {
1053 { "ntsc", 720, 480 },
1054 { "pal", 720, 576 },
1055 { "qntsc", 352, 240 }, /* VCD compliant NTSC */
1056 { "qpal", 352, 288 }, /* VCD compliant PAL */
1057 { "sntsc", 640, 480 }, /* square pixel NTSC */
1058 { "spal", 768, 576 }, /* square pixel PAL */
1059 { "film", 352, 240 },
1060 { "ntsc-film", 352, 240 },
1061 { "sqcif", 128, 96 },
1062 { "qcif", 176, 144 },
1063 { "cif", 352, 288 },
1064 { "4cif", 704, 576 },
1065 { "16cif", 1408,1152 },
1066 { "qqvga", 160, 120 },
1067 { "qvga", 320, 240 },
1068 { "vga", 640, 480 },
1069 { "svga", 800, 600 },
1070 { "xga", 1024, 768 },
1071 { "uxga", 1600,1200 },
1072 { "qxga", 2048,1536 },
1073 { "sxga", 1280,1024 },
1074 { "qsxga", 2560,2048 },
1075 { "hsxga", 5120,4096 },
1076 { "wvga", 852, 480 },
1077 { "wxga", 1366, 768 },
1078 { "wsxga", 1600,1024 },
1079 { "wuxga", 1920,1200 },
1080 { "woxga", 2560,1600 },
1081 { "wqsxga", 3200,2048 },
1082 { "wquxga", 3840,2400 },
1083 { "whsxga", 6400,4096 },
1084 { "whuxga", 7680,4800 },
1085 { "cga", 320, 200 },
1086 { "ega", 640, 350 },
1087 { "hd480", 852, 480 },
1088 { "hd720", 1280, 720 },
1089 { "hd1080", 1920,1080 },
1092 static const VideoFrameRateAbbr video_frame_rate_abbrs
[]= {
1093 { "ntsc", 30000, 1001 },
1095 { "qntsc", 30000, 1001 }, /* VCD compliant NTSC */
1096 { "qpal", 25, 1 }, /* VCD compliant PAL */
1097 { "sntsc", 30000, 1001 }, /* square pixel NTSC */
1098 { "spal", 25, 1 }, /* square pixel PAL */
1100 { "ntsc-film", 24000, 1001 },
1103 int av_parse_video_frame_size(int *width_ptr
, int *height_ptr
, const char *str
)
1106 int n
= FF_ARRAY_ELEMS(video_frame_size_abbrs
);
1108 int frame_width
= 0, frame_height
= 0;
1111 if (!strcmp(video_frame_size_abbrs
[i
].abbr
, str
)) {
1112 frame_width
= video_frame_size_abbrs
[i
].width
;
1113 frame_height
= video_frame_size_abbrs
[i
].height
;
1119 frame_width
= strtol(p
, &p
, 10);
1122 frame_height
= strtol(p
, &p
, 10);
1124 if (frame_width
<= 0 || frame_height
<= 0)
1126 *width_ptr
= frame_width
;
1127 *height_ptr
= frame_height
;
1131 int av_parse_video_frame_rate(AVRational
*frame_rate
, const char *arg
)
1134 int n
= FF_ARRAY_ELEMS(video_frame_rate_abbrs
);
1137 /* First, we check our abbreviation table */
1138 for (i
= 0; i
< n
; ++i
)
1139 if (!strcmp(video_frame_rate_abbrs
[i
].abbr
, arg
)) {
1140 frame_rate
->num
= video_frame_rate_abbrs
[i
].rate_num
;
1141 frame_rate
->den
= video_frame_rate_abbrs
[i
].rate_den
;
1145 /* Then, we try to parse it as fraction */
1146 cp
= strchr(arg
, '/');
1148 cp
= strchr(arg
, ':');
1151 frame_rate
->num
= strtol(arg
, &cpp
, 10);
1152 if (cpp
!= arg
|| cpp
== cp
)
1153 frame_rate
->den
= strtol(cp
+1, &cpp
, 10);
1155 frame_rate
->num
= 0;
1158 /* Finally we give up and parse it as double */
1159 AVRational time_base
= av_d2q(strtod(arg
, 0), 1001000);
1160 frame_rate
->den
= time_base
.den
;
1161 frame_rate
->num
= time_base
.num
;
1163 if (!frame_rate
->num
|| !frame_rate
->den
)
1169 void ff_log_missing_feature(void *avc
, const char *feature
, int want_sample
)
1171 av_log(avc
, AV_LOG_WARNING
, "%s not implemented. Update your FFmpeg "
1172 "version to the newest one from SVN. If the problem still "
1173 "occurs, it means that your file has a feature which has not "
1174 "been implemented.", feature
);
1176 ff_log_ask_for_sample(avc
, NULL
);
1178 av_log(avc
, AV_LOG_WARNING
, "\n");
1181 void ff_log_ask_for_sample(void *avc
, const char *msg
)
1184 av_log(avc
, AV_LOG_WARNING
, "%s ", msg
);
1185 av_log(avc
, AV_LOG_WARNING
, "If you want to help, upload a sample "
1186 "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
1187 "and contact the ffmpeg-devel mailing list.\n");
1190 static AVHWAccel
*first_hwaccel
= NULL
;
1192 void av_register_hwaccel(AVHWAccel
*hwaccel
)
1194 AVHWAccel
**p
= &first_hwaccel
;
1198 hwaccel
->next
= NULL
;
1201 AVHWAccel
*av_hwaccel_next(AVHWAccel
*hwaccel
)
1203 return hwaccel
? hwaccel
->next
: first_hwaccel
;
1206 AVHWAccel
*ff_find_hwaccel(enum CodecID codec_id
, enum PixelFormat pix_fmt
)
1208 AVHWAccel
*hwaccel
=NULL
;
1210 while((hwaccel
= av_hwaccel_next(hwaccel
))){
1211 if ( hwaccel
->id
== codec_id
1212 && hwaccel
->pix_fmt
== pix_fmt
)