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 /* encoder management */
84 static AVCodec
*first_avcodec
= NULL
;
86 AVCodec
*av_codec_next(AVCodec
*c
){
88 else return first_avcodec
;
91 void avcodec_register(AVCodec
*codec
)
96 while (*p
!= NULL
) p
= &(*p
)->next
;
101 #if LIBAVCODEC_VERSION_MAJOR < 53
102 void register_avcodec(AVCodec
*codec
)
104 avcodec_register(codec
);
108 void avcodec_set_dimensions(AVCodecContext
*s
, int width
, int height
){
109 s
->coded_width
= width
;
110 s
->coded_height
= height
;
111 s
->width
= -((-width
)>>s
->lowres
);
112 s
->height
= -((-height
)>>s
->lowres
);
115 typedef struct InternalBuffer
{
121 enum PixelFormat pix_fmt
;
124 #define INTERNAL_BUFFER_SIZE 32
126 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
128 void avcodec_align_dimensions(AVCodecContext
*s
, int *width
, int *height
){
133 case PIX_FMT_YUV420P
:
134 case PIX_FMT_YUYV422
:
135 case PIX_FMT_UYVY422
:
136 case PIX_FMT_YUV422P
:
137 case PIX_FMT_YUV444P
:
139 case PIX_FMT_GRAY16BE
:
140 case PIX_FMT_GRAY16LE
:
141 case PIX_FMT_YUVJ420P
:
142 case PIX_FMT_YUVJ422P
:
143 case PIX_FMT_YUVJ444P
:
144 case PIX_FMT_YUVA420P
:
145 w_align
= 16; //FIXME check for non mpeg style codecs and use less alignment
148 case PIX_FMT_YUV411P
:
149 case PIX_FMT_UYYVYY411
:
153 case PIX_FMT_YUV410P
:
154 if(s
->codec_id
== CODEC_ID_SVQ1
){
159 if(s
->codec_id
== CODEC_ID_RPZA
){
166 if(s
->codec_id
== CODEC_ID_SMC
){
172 if((s
->codec_id
== CODEC_ID_MSZH
) || (s
->codec_id
== CODEC_ID_ZLIB
)){
183 *width
= ALIGN(*width
, w_align
);
184 *height
= ALIGN(*height
, h_align
);
185 if(s
->codec_id
== CODEC_ID_H264
)
186 *height
+=2; // some of the optimized chroma MC reads one line too much
189 int avcodec_check_dimensions(void *av_log_ctx
, unsigned int w
, unsigned int h
){
190 if((int)w
>0 && (int)h
>0 && (w
+128)*(uint64_t)(h
+128) < INT_MAX
/4)
193 av_log(av_log_ctx
, AV_LOG_ERROR
, "picture size invalid (%ux%u)\n", w
, h
);
197 int avcodec_default_get_buffer(AVCodecContext
*s
, AVFrame
*pic
){
204 if(pic
->data
[0]!=NULL
) {
205 av_log(s
, AV_LOG_ERROR
, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
208 if(s
->internal_buffer_count
>= INTERNAL_BUFFER_SIZE
) {
209 av_log(s
, AV_LOG_ERROR
, "internal_buffer_count overflow (missing release_buffer?)\n");
213 if(avcodec_check_dimensions(s
,w
,h
))
216 if(s
->internal_buffer
==NULL
){
217 s
->internal_buffer
= av_mallocz((INTERNAL_BUFFER_SIZE
+1)*sizeof(InternalBuffer
));
220 s
->internal_buffer
= av_fast_realloc(
222 &s
->internal_buffer_size
,
223 sizeof(InternalBuffer
)*FFMAX(99, s
->internal_buffer_count
+1)/*FIXME*/
227 buf
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
228 picture_number
= &(((InternalBuffer
*)s
->internal_buffer
)[INTERNAL_BUFFER_SIZE
]).last_pic_num
; //FIXME ugly hack
231 if(buf
->base
[0] && (buf
->width
!= w
|| buf
->height
!= h
|| buf
->pix_fmt
!= s
->pix_fmt
)){
233 av_freep(&buf
->base
[i
]);
239 pic
->age
= *picture_number
- buf
->last_pic_num
;
240 buf
->last_pic_num
= *picture_number
;
242 int h_chroma_shift
, v_chroma_shift
;
249 avcodec_get_chroma_sub_sample(s
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
251 avcodec_align_dimensions(s
, &w
, &h
);
253 if(!(s
->flags
&CODEC_FLAG_EMU_EDGE
)){
259 // NOTE: do not align linesizes individually, this breaks e.g. assumptions
260 // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
261 ff_fill_linesize(&picture
, s
->pix_fmt
, w
);
262 // increase alignment of w for next try (rhs gives the lowest bit set in w)
267 //STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
268 //we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
269 //picture size unneccessarily in some cases. The solution here is not
270 //pretty and better ideas are welcome!
272 if(s
->codec_id
== CODEC_ID_SVQ1
)
276 stride_align
[i
] = STRIDE_ALIGN
;
277 unaligned
|= picture
.linesize
[i
] % stride_align
[i
];
281 tmpsize
= ff_fill_pointer(&picture
, NULL
, s
->pix_fmt
, h
);
285 for (i
=0; i
<3 && picture
.data
[i
+1]; i
++)
286 size
[i
] = picture
.data
[i
+1] - picture
.data
[i
];
287 size
[i
] = tmpsize
- (picture
.data
[i
] - picture
.data
[0]);
289 buf
->last_pic_num
= -256*256*256*64;
290 memset(buf
->base
, 0, sizeof(buf
->base
));
291 memset(buf
->data
, 0, sizeof(buf
->data
));
293 for(i
=0; i
<4 && size
[i
]; i
++){
294 const int h_shift
= i
==0 ? 0 : h_chroma_shift
;
295 const int v_shift
= i
==0 ? 0 : v_chroma_shift
;
297 buf
->linesize
[i
]= picture
.linesize
[i
];
299 buf
->base
[i
]= av_malloc(size
[i
]+16); //FIXME 16
300 if(buf
->base
[i
]==NULL
) return -1;
301 memset(buf
->base
[i
], 128, size
[i
]);
303 // no edge if EDEG EMU or not planar YUV
304 if((s
->flags
&CODEC_FLAG_EMU_EDGE
) || !size
[2])
305 buf
->data
[i
] = buf
->base
[i
];
307 buf
->data
[i
] = buf
->base
[i
] + ALIGN((buf
->linesize
[i
]*EDGE_WIDTH
>>v_shift
) + (EDGE_WIDTH
>>h_shift
), stride_align
[i
]);
309 if(size
[1] && !size
[2])
310 ff_set_systematic_pal((uint32_t*)buf
->data
[1], s
->pix_fmt
);
311 buf
->width
= s
->width
;
312 buf
->height
= s
->height
;
313 buf
->pix_fmt
= s
->pix_fmt
;
314 pic
->age
= 256*256*256*64;
316 pic
->type
= FF_BUFFER_TYPE_INTERNAL
;
319 pic
->base
[i
]= buf
->base
[i
];
320 pic
->data
[i
]= buf
->data
[i
];
321 pic
->linesize
[i
]= buf
->linesize
[i
];
323 s
->internal_buffer_count
++;
325 pic
->reordered_opaque
= s
->reordered_opaque
;
327 if(s
->debug
&FF_DEBUG_BUFFERS
)
328 av_log(s
, AV_LOG_DEBUG
, "default_get_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
333 void avcodec_default_release_buffer(AVCodecContext
*s
, AVFrame
*pic
){
335 InternalBuffer
*buf
, *last
;
337 assert(pic
->type
==FF_BUFFER_TYPE_INTERNAL
);
338 assert(s
->internal_buffer_count
);
340 buf
= NULL
; /* avoids warning */
341 for(i
=0; i
<s
->internal_buffer_count
; i
++){ //just 3-5 checks so is not worth to optimize
342 buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
343 if(buf
->data
[0] == pic
->data
[0])
346 assert(i
< s
->internal_buffer_count
);
347 s
->internal_buffer_count
--;
348 last
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
350 FFSWAP(InternalBuffer
, *buf
, *last
);
354 // pic->base[i]=NULL;
356 //printf("R%X\n", pic->opaque);
358 if(s
->debug
&FF_DEBUG_BUFFERS
)
359 av_log(s
, AV_LOG_DEBUG
, "default_release_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
362 int avcodec_default_reget_buffer(AVCodecContext
*s
, AVFrame
*pic
){
366 /* If no picture return a new buffer */
367 if(pic
->data
[0] == NULL
) {
368 /* We will copy from buffer, so must be readable */
369 pic
->buffer_hints
|= FF_BUFFER_HINTS_READABLE
;
370 return s
->get_buffer(s
, pic
);
373 /* If internal buffer type return the same buffer */
374 if(pic
->type
== FF_BUFFER_TYPE_INTERNAL
)
378 * Not internal type and reget_buffer not overridden, emulate cr buffer
381 for(i
= 0; i
< 4; i
++)
382 pic
->data
[i
] = pic
->base
[i
] = NULL
;
384 /* Allocate new frame */
385 if (s
->get_buffer(s
, pic
))
387 /* Copy image data from old buffer to new buffer */
388 av_picture_copy((AVPicture
*)pic
, (AVPicture
*)&temp_pic
, s
->pix_fmt
, s
->width
,
390 s
->release_buffer(s
, &temp_pic
); // Release old frame
394 int avcodec_default_execute(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
),void *arg
, int *ret
, int count
, int size
){
397 for(i
=0; i
<count
; i
++){
398 int r
= func(c
, (char*)arg
+ i
*size
);
404 enum PixelFormat
avcodec_default_get_format(struct AVCodecContext
*s
, const enum PixelFormat
*fmt
){
405 while (*fmt
!= PIX_FMT_NONE
&& ff_is_hwaccel_pix_fmt(*fmt
))
410 void avcodec_get_frame_defaults(AVFrame
*pic
){
411 memset(pic
, 0, sizeof(AVFrame
));
413 pic
->pts
= AV_NOPTS_VALUE
;
417 AVFrame
*avcodec_alloc_frame(void){
418 AVFrame
*pic
= av_malloc(sizeof(AVFrame
));
420 if(pic
==NULL
) return NULL
;
422 avcodec_get_frame_defaults(pic
);
427 int attribute_align_arg
avcodec_open(AVCodecContext
*avctx
, AVCodec
*codec
)
431 entangled_thread_counter
++;
432 if(entangled_thread_counter
!= 1){
433 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
437 if(avctx
->codec
|| !codec
)
440 if (codec
->priv_data_size
> 0) {
441 avctx
->priv_data
= av_mallocz(codec
->priv_data_size
);
442 if (!avctx
->priv_data
) {
443 ret
= AVERROR(ENOMEM
);
447 avctx
->priv_data
= NULL
;
450 if(avctx
->coded_width
&& avctx
->coded_height
)
451 avcodec_set_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
);
452 else if(avctx
->width
&& avctx
->height
)
453 avcodec_set_dimensions(avctx
, avctx
->width
, avctx
->height
);
455 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
)){
456 av_freep(&avctx
->priv_data
);
457 ret
= AVERROR(EINVAL
);
461 avctx
->codec
= codec
;
462 avctx
->codec_id
= codec
->id
;
463 avctx
->frame_number
= 0;
464 if(avctx
->codec
->init
){
465 ret
= avctx
->codec
->init(avctx
);
467 av_freep(&avctx
->priv_data
);
474 entangled_thread_counter
--;
478 int attribute_align_arg
avcodec_encode_audio(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
479 const short *samples
)
481 if(buf_size
< FF_MIN_BUFFER_SIZE
&& 0){
482 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
485 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || samples
){
486 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, samples
);
487 avctx
->frame_number
++;
493 int attribute_align_arg
avcodec_encode_video(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
496 if(buf_size
< FF_MIN_BUFFER_SIZE
){
497 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
500 if(avcodec_check_dimensions(avctx
,avctx
->width
,avctx
->height
))
502 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || pict
){
503 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, pict
);
504 avctx
->frame_number
++;
505 emms_c(); //needed to avoid an emms_c() call before every return;
512 int avcodec_encode_subtitle(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
513 const AVSubtitle
*sub
)
516 if(sub
->start_display_time
) {
517 av_log(avctx
, AV_LOG_ERROR
, "start_display_time must be 0.\n");
520 if(sub
->num_rects
== 0 || !sub
->rects
)
522 ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, sub
);
523 avctx
->frame_number
++;
527 int attribute_align_arg
avcodec_decode_video(AVCodecContext
*avctx
, AVFrame
*picture
,
528 int *got_picture_ptr
,
529 const uint8_t *buf
, int buf_size
)
534 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
))
536 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || buf_size
){
537 ret
= avctx
->codec
->decode(avctx
, picture
, got_picture_ptr
,
540 emms_c(); //needed to avoid an emms_c() call before every return;
542 if (*got_picture_ptr
)
543 avctx
->frame_number
++;
550 int attribute_align_arg
avcodec_decode_audio2(AVCodecContext
*avctx
, int16_t *samples
,
552 const uint8_t *buf
, int buf_size
)
556 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || buf_size
){
557 //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
558 if(*frame_size_ptr
< AVCODEC_MAX_AUDIO_FRAME_SIZE
){
559 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
562 if(*frame_size_ptr
< FF_MIN_BUFFER_SIZE
||
563 *frame_size_ptr
< avctx
->channels
* avctx
->frame_size
* sizeof(int16_t)){
564 av_log(avctx
, AV_LOG_ERROR
, "buffer %d too small\n", *frame_size_ptr
);
568 ret
= avctx
->codec
->decode(avctx
, samples
, frame_size_ptr
,
570 avctx
->frame_number
++;
578 int avcodec_decode_subtitle(AVCodecContext
*avctx
, AVSubtitle
*sub
,
580 const uint8_t *buf
, int buf_size
)
585 ret
= avctx
->codec
->decode(avctx
, sub
, got_sub_ptr
,
588 avctx
->frame_number
++;
592 int avcodec_close(AVCodecContext
*avctx
)
594 entangled_thread_counter
++;
595 if(entangled_thread_counter
!= 1){
596 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
597 entangled_thread_counter
--;
601 if (HAVE_THREADS
&& avctx
->thread_opaque
)
602 avcodec_thread_free(avctx
);
603 if (avctx
->codec
->close
)
604 avctx
->codec
->close(avctx
);
605 avcodec_default_free_buffers(avctx
);
606 av_freep(&avctx
->priv_data
);
608 entangled_thread_counter
--;
612 AVCodec
*avcodec_find_encoder(enum CodecID id
)
617 if (p
->encode
!= NULL
&& p
->id
== id
)
624 AVCodec
*avcodec_find_encoder_by_name(const char *name
)
631 if (p
->encode
!= NULL
&& strcmp(name
,p
->name
) == 0)
638 AVCodec
*avcodec_find_decoder(enum CodecID id
)
643 if (p
->decode
!= NULL
&& p
->id
== id
)
650 AVCodec
*avcodec_find_decoder_by_name(const char *name
)
657 if (p
->decode
!= NULL
&& strcmp(name
,p
->name
) == 0)
664 void avcodec_string(char *buf
, int buf_size
, AVCodecContext
*enc
, int encode
)
666 const char *codec_name
;
670 AVRational display_aspect_ratio
;
673 p
= avcodec_find_encoder(enc
->codec_id
);
675 p
= avcodec_find_decoder(enc
->codec_id
);
678 codec_name
= p
->name
;
679 } else if (enc
->codec_id
== CODEC_ID_MPEG2TS
) {
680 /* fake mpeg2 transport stream codec (currently not
682 codec_name
= "mpeg2ts";
683 } else if (enc
->codec_name
[0] != '\0') {
684 codec_name
= enc
->codec_name
;
686 /* output avi tags */
687 if( isprint(enc
->codec_tag
&0xFF) && isprint((enc
->codec_tag
>>8)&0xFF)
688 && isprint((enc
->codec_tag
>>16)&0xFF) && isprint((enc
->codec_tag
>>24)&0xFF)){
689 snprintf(buf1
, sizeof(buf1
), "%c%c%c%c / 0x%04X",
690 enc
->codec_tag
& 0xff,
691 (enc
->codec_tag
>> 8) & 0xff,
692 (enc
->codec_tag
>> 16) & 0xff,
693 (enc
->codec_tag
>> 24) & 0xff,
696 snprintf(buf1
, sizeof(buf1
), "0x%04x", enc
->codec_tag
);
701 switch(enc
->codec_type
) {
702 case CODEC_TYPE_VIDEO
:
703 snprintf(buf
, buf_size
,
705 codec_name
, enc
->mb_decision
? " (hq)" : "");
706 if (enc
->pix_fmt
!= PIX_FMT_NONE
) {
707 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
709 avcodec_get_pix_fmt_name(enc
->pix_fmt
));
712 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
714 enc
->width
, enc
->height
);
715 if (enc
->sample_aspect_ratio
.num
) {
716 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
717 enc
->width
*enc
->sample_aspect_ratio
.num
,
718 enc
->height
*enc
->sample_aspect_ratio
.den
,
720 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
721 " [PAR %d:%d DAR %d:%d]",
722 enc
->sample_aspect_ratio
.num
, enc
->sample_aspect_ratio
.den
,
723 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
725 if(av_log_get_level() >= AV_LOG_DEBUG
){
726 int g
= av_gcd(enc
->time_base
.num
, enc
->time_base
.den
);
727 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
729 enc
->time_base
.num
/g
, enc
->time_base
.den
/g
);
733 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
734 ", q=%d-%d", enc
->qmin
, enc
->qmax
);
736 bitrate
= enc
->bit_rate
;
738 case CODEC_TYPE_AUDIO
:
739 snprintf(buf
, buf_size
,
742 if (enc
->sample_rate
) {
743 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
744 ", %d Hz", enc
->sample_rate
);
746 av_strlcat(buf
, ", ", buf_size
);
747 avcodec_get_channel_layout_string(buf
+ strlen(buf
), buf_size
- strlen(buf
), enc
->channels
, enc
->channel_layout
);
748 if (enc
->sample_fmt
!= SAMPLE_FMT_NONE
) {
749 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
750 ", %s", avcodec_get_sample_fmt_name(enc
->sample_fmt
));
753 /* for PCM codecs, compute bitrate directly */
754 switch(enc
->codec_id
) {
755 case CODEC_ID_PCM_F64BE
:
756 case CODEC_ID_PCM_F64LE
:
757 bitrate
= enc
->sample_rate
* enc
->channels
* 64;
759 case CODEC_ID_PCM_S32LE
:
760 case CODEC_ID_PCM_S32BE
:
761 case CODEC_ID_PCM_U32LE
:
762 case CODEC_ID_PCM_U32BE
:
763 case CODEC_ID_PCM_F32BE
:
764 case CODEC_ID_PCM_F32LE
:
765 bitrate
= enc
->sample_rate
* enc
->channels
* 32;
767 case CODEC_ID_PCM_S24LE
:
768 case CODEC_ID_PCM_S24BE
:
769 case CODEC_ID_PCM_U24LE
:
770 case CODEC_ID_PCM_U24BE
:
771 case CODEC_ID_PCM_S24DAUD
:
772 bitrate
= enc
->sample_rate
* enc
->channels
* 24;
774 case CODEC_ID_PCM_S16LE
:
775 case CODEC_ID_PCM_S16BE
:
776 case CODEC_ID_PCM_S16LE_PLANAR
:
777 case CODEC_ID_PCM_U16LE
:
778 case CODEC_ID_PCM_U16BE
:
779 bitrate
= enc
->sample_rate
* enc
->channels
* 16;
781 case CODEC_ID_PCM_S8
:
782 case CODEC_ID_PCM_U8
:
783 case CODEC_ID_PCM_ALAW
:
784 case CODEC_ID_PCM_MULAW
:
785 case CODEC_ID_PCM_ZORK
:
786 bitrate
= enc
->sample_rate
* enc
->channels
* 8;
789 bitrate
= enc
->bit_rate
;
793 case CODEC_TYPE_DATA
:
794 snprintf(buf
, buf_size
, "Data: %s", codec_name
);
795 bitrate
= enc
->bit_rate
;
797 case CODEC_TYPE_SUBTITLE
:
798 snprintf(buf
, buf_size
, "Subtitle: %s", codec_name
);
799 bitrate
= enc
->bit_rate
;
801 case CODEC_TYPE_ATTACHMENT
:
802 snprintf(buf
, buf_size
, "Attachment: %s", codec_name
);
803 bitrate
= enc
->bit_rate
;
806 snprintf(buf
, buf_size
, "Invalid Codec type %d", enc
->codec_type
);
810 if (enc
->flags
& CODEC_FLAG_PASS1
)
811 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
813 if (enc
->flags
& CODEC_FLAG_PASS2
)
814 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
818 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
819 ", %d kb/s", bitrate
/ 1000);
823 unsigned avcodec_version( void )
825 return LIBAVCODEC_VERSION_INT
;
828 void avcodec_init(void)
830 static int initialized
= 0;
832 if (initialized
!= 0)
836 dsputil_static_init();
839 void avcodec_flush_buffers(AVCodecContext
*avctx
)
841 if(avctx
->codec
->flush
)
842 avctx
->codec
->flush(avctx
);
845 void avcodec_default_free_buffers(AVCodecContext
*s
){
848 if(s
->internal_buffer
==NULL
) return;
850 for(i
=0; i
<INTERNAL_BUFFER_SIZE
; i
++){
851 InternalBuffer
*buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
853 av_freep(&buf
->base
[j
]);
857 av_freep(&s
->internal_buffer
);
859 s
->internal_buffer_count
=0;
862 char av_get_pict_type_char(int pict_type
){
864 case FF_I_TYPE
: return 'I';
865 case FF_P_TYPE
: return 'P';
866 case FF_B_TYPE
: return 'B';
867 case FF_S_TYPE
: return 'S';
868 case FF_SI_TYPE
:return 'i';
869 case FF_SP_TYPE
:return 'p';
870 case FF_BI_TYPE
:return 'b';
875 int av_get_bits_per_sample(enum CodecID codec_id
){
877 case CODEC_ID_ADPCM_SBPRO_2
:
879 case CODEC_ID_ADPCM_SBPRO_3
:
881 case CODEC_ID_ADPCM_SBPRO_4
:
882 case CODEC_ID_ADPCM_CT
:
884 case CODEC_ID_PCM_ALAW
:
885 case CODEC_ID_PCM_MULAW
:
886 case CODEC_ID_PCM_S8
:
887 case CODEC_ID_PCM_U8
:
888 case CODEC_ID_PCM_ZORK
:
890 case CODEC_ID_PCM_S16BE
:
891 case CODEC_ID_PCM_S16LE
:
892 case CODEC_ID_PCM_S16LE_PLANAR
:
893 case CODEC_ID_PCM_U16BE
:
894 case CODEC_ID_PCM_U16LE
:
896 case CODEC_ID_PCM_S24DAUD
:
897 case CODEC_ID_PCM_S24BE
:
898 case CODEC_ID_PCM_S24LE
:
899 case CODEC_ID_PCM_U24BE
:
900 case CODEC_ID_PCM_U24LE
:
902 case CODEC_ID_PCM_S32BE
:
903 case CODEC_ID_PCM_S32LE
:
904 case CODEC_ID_PCM_U32BE
:
905 case CODEC_ID_PCM_U32LE
:
906 case CODEC_ID_PCM_F32BE
:
907 case CODEC_ID_PCM_F32LE
:
909 case CODEC_ID_PCM_F64BE
:
910 case CODEC_ID_PCM_F64LE
:
917 int av_get_bits_per_sample_format(enum SampleFormat sample_fmt
) {
918 switch (sample_fmt
) {
934 int avcodec_thread_init(AVCodecContext
*s
, int thread_count
){
939 unsigned int av_xiphlacing(unsigned char *s
, unsigned int v
)
953 /* Wrapper to work around the lack of mkstemp() on mingw/cygin.
954 * Also, tries to create file in /tmp first, if possible.
955 * *prefix can be a character constant; *filename will be allocated internally.
956 * Returns file descriptor of opened file (or -1 on error)
957 * and opened file name in **filename. */
958 int av_tempfile(char *prefix
, char **filename
) {
961 *filename
= tempnam(".", prefix
);
963 size_t len
= strlen(prefix
) + 12; /* room for "/tmp/" and "XXXXXX\0" */
964 *filename
= av_malloc(len
);
966 /* -----common section-----*/
967 if (*filename
== NULL
) {
968 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot allocate file name\n");
972 fd
= open(*filename
, O_RDWR
| O_BINARY
| O_CREAT
, 0444);
974 snprintf(*filename
, len
, "/tmp/%sXXXXXX", prefix
);
975 fd
= mkstemp(*filename
);
977 snprintf(*filename
, len
, "./%sXXXXXX", prefix
);
978 fd
= mkstemp(*filename
);
981 /* -----common section-----*/
983 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot open temporary file %s\n", *filename
);
986 return fd
; /* success */
992 } VideoFrameSizeAbbr
;
996 int rate_num
, rate_den
;
997 } VideoFrameRateAbbr
;
999 static const VideoFrameSizeAbbr video_frame_size_abbrs
[] = {
1000 { "ntsc", 720, 480 },
1001 { "pal", 720, 576 },
1002 { "qntsc", 352, 240 }, /* VCD compliant NTSC */
1003 { "qpal", 352, 288 }, /* VCD compliant PAL */
1004 { "sntsc", 640, 480 }, /* square pixel NTSC */
1005 { "spal", 768, 576 }, /* square pixel PAL */
1006 { "film", 352, 240 },
1007 { "ntsc-film", 352, 240 },
1008 { "sqcif", 128, 96 },
1009 { "qcif", 176, 144 },
1010 { "cif", 352, 288 },
1011 { "4cif", 704, 576 },
1012 { "qqvga", 160, 120 },
1013 { "qvga", 320, 240 },
1014 { "vga", 640, 480 },
1015 { "svga", 800, 600 },
1016 { "xga", 1024, 768 },
1017 { "uxga", 1600,1200 },
1018 { "qxga", 2048,1536 },
1019 { "sxga", 1280,1024 },
1020 { "qsxga", 2560,2048 },
1021 { "hsxga", 5120,4096 },
1022 { "wvga", 852, 480 },
1023 { "wxga", 1366, 768 },
1024 { "wsxga", 1600,1024 },
1025 { "wuxga", 1920,1200 },
1026 { "woxga", 2560,1600 },
1027 { "wqsxga", 3200,2048 },
1028 { "wquxga", 3840,2400 },
1029 { "whsxga", 6400,4096 },
1030 { "whuxga", 7680,4800 },
1031 { "cga", 320, 200 },
1032 { "ega", 640, 350 },
1033 { "hd480", 852, 480 },
1034 { "hd720", 1280, 720 },
1035 { "hd1080", 1920,1080 },
1038 static const VideoFrameRateAbbr video_frame_rate_abbrs
[]= {
1039 { "ntsc", 30000, 1001 },
1041 { "qntsc", 30000, 1001 }, /* VCD compliant NTSC */
1042 { "qpal", 25, 1 }, /* VCD compliant PAL */
1043 { "sntsc", 30000, 1001 }, /* square pixel NTSC */
1044 { "spal", 25, 1 }, /* square pixel PAL */
1046 { "ntsc-film", 24000, 1001 },
1049 int av_parse_video_frame_size(int *width_ptr
, int *height_ptr
, const char *str
)
1052 int n
= FF_ARRAY_ELEMS(video_frame_size_abbrs
);
1054 int frame_width
= 0, frame_height
= 0;
1057 if (!strcmp(video_frame_size_abbrs
[i
].abbr
, str
)) {
1058 frame_width
= video_frame_size_abbrs
[i
].width
;
1059 frame_height
= video_frame_size_abbrs
[i
].height
;
1065 frame_width
= strtol(p
, &p
, 10);
1068 frame_height
= strtol(p
, &p
, 10);
1070 if (frame_width
<= 0 || frame_height
<= 0)
1072 *width_ptr
= frame_width
;
1073 *height_ptr
= frame_height
;
1077 int av_parse_video_frame_rate(AVRational
*frame_rate
, const char *arg
)
1080 int n
= FF_ARRAY_ELEMS(video_frame_rate_abbrs
);
1083 /* First, we check our abbreviation table */
1084 for (i
= 0; i
< n
; ++i
)
1085 if (!strcmp(video_frame_rate_abbrs
[i
].abbr
, arg
)) {
1086 frame_rate
->num
= video_frame_rate_abbrs
[i
].rate_num
;
1087 frame_rate
->den
= video_frame_rate_abbrs
[i
].rate_den
;
1091 /* Then, we try to parse it as fraction */
1092 cp
= strchr(arg
, '/');
1094 cp
= strchr(arg
, ':');
1097 frame_rate
->num
= strtol(arg
, &cpp
, 10);
1098 if (cpp
!= arg
|| cpp
== cp
)
1099 frame_rate
->den
= strtol(cp
+1, &cpp
, 10);
1101 frame_rate
->num
= 0;
1104 /* Finally we give up and parse it as double */
1105 AVRational time_base
= av_d2q(strtod(arg
, 0), 1001000);
1106 frame_rate
->den
= time_base
.den
;
1107 frame_rate
->num
= time_base
.num
;
1109 if (!frame_rate
->num
|| !frame_rate
->den
)
1115 void ff_log_missing_feature(void *avc
, const char *feature
, int want_sample
)
1117 av_log(avc
, AV_LOG_WARNING
, "%s not implemented. Update your FFmpeg "
1118 "version to the newest one from SVN. If the problem still "
1119 "occurs, it means that your file has a feature which has not "
1120 "been implemented.", feature
);
1122 ff_log_ask_for_sample(avc
, NULL
);
1124 av_log(avc
, AV_LOG_WARNING
, "\n");
1127 void ff_log_ask_for_sample(void *avc
, const char *msg
)
1130 av_log(avc
, AV_LOG_WARNING
, "%s ", msg
);
1131 av_log(avc
, AV_LOG_WARNING
, "If you want to help, upload a sample "
1132 "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
1133 "and contact the ffmpeg-devel mailing list.\n");
1136 static AVHWAccel
*first_hwaccel
= NULL
;
1138 void av_register_hwaccel(AVHWAccel
*hwaccel
)
1140 AVHWAccel
**p
= &first_hwaccel
;
1144 hwaccel
->next
= NULL
;
1147 AVHWAccel
*av_hwaccel_next(AVHWAccel
*hwaccel
)
1149 return hwaccel
? hwaccel
->next
: first_hwaccel
;
1152 AVHWAccel
*ff_find_hwaccel(enum CodecID codec_id
, enum PixelFormat pix_fmt
)
1154 AVHWAccel
*hwaccel
=NULL
;
1156 while((hwaccel
= av_hwaccel_next(hwaccel
))){
1157 if ( hwaccel
->id
== codec_id
1158 && hwaccel
->pix_fmt
== pix_fmt
)