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;
68 int (*ff_lockmgr_cb
)(void **mutex
, enum AVLockOp op
);
69 static void *codec_mutex
;
71 void *av_fast_realloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
76 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
78 ptr
= av_realloc(ptr
, *size
);
79 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
85 void av_fast_malloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
90 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
92 *p
= av_malloc(*size
);
96 /* encoder management */
97 static AVCodec
*first_avcodec
= NULL
;
99 AVCodec
*av_codec_next(AVCodec
*c
){
100 if(c
) return c
->next
;
101 else return first_avcodec
;
104 void avcodec_register(AVCodec
*codec
)
109 while (*p
!= NULL
) p
= &(*p
)->next
;
114 #if LIBAVCODEC_VERSION_MAJOR < 53
115 void register_avcodec(AVCodec
*codec
)
117 avcodec_register(codec
);
121 void avcodec_set_dimensions(AVCodecContext
*s
, int width
, int height
){
122 s
->coded_width
= width
;
123 s
->coded_height
= height
;
124 s
->width
= -((-width
)>>s
->lowres
);
125 s
->height
= -((-height
)>>s
->lowres
);
128 typedef struct InternalBuffer
{
134 enum PixelFormat pix_fmt
;
137 #define INTERNAL_BUFFER_SIZE 32
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
= FFALIGN(*width
, w_align
);
197 *height
= FFALIGN(*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
/8)
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
] + FFALIGN((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 int avcodec_default_execute2(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
, int jobnr
, int threadnr
),void *arg
, int *ret
, int count
){
420 for(i
=0; i
<count
; i
++){
421 int r
= func(c
, arg
, i
, 0);
427 enum PixelFormat
avcodec_default_get_format(struct AVCodecContext
*s
, const enum PixelFormat
*fmt
){
428 while (*fmt
!= PIX_FMT_NONE
&& ff_is_hwaccel_pix_fmt(*fmt
))
433 void avcodec_get_frame_defaults(AVFrame
*pic
){
434 memset(pic
, 0, sizeof(AVFrame
));
436 pic
->pts
= AV_NOPTS_VALUE
;
440 AVFrame
*avcodec_alloc_frame(void){
441 AVFrame
*pic
= av_malloc(sizeof(AVFrame
));
443 if(pic
==NULL
) return NULL
;
445 avcodec_get_frame_defaults(pic
);
450 int attribute_align_arg
avcodec_open(AVCodecContext
*avctx
, AVCodec
*codec
)
454 /* If there is a user-supplied mutex locking routine, call it. */
456 if ((*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_OBTAIN
))
460 entangled_thread_counter
++;
461 if(entangled_thread_counter
!= 1){
462 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
466 if(avctx
->codec
|| !codec
)
469 if (codec
->priv_data_size
> 0) {
470 avctx
->priv_data
= av_mallocz(codec
->priv_data_size
);
471 if (!avctx
->priv_data
) {
472 ret
= AVERROR(ENOMEM
);
476 avctx
->priv_data
= NULL
;
479 if(avctx
->coded_width
&& avctx
->coded_height
)
480 avcodec_set_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
);
481 else if(avctx
->width
&& avctx
->height
)
482 avcodec_set_dimensions(avctx
, avctx
->width
, avctx
->height
);
484 #define SANE_NB_CHANNELS 128U
485 if (((avctx
->coded_width
|| avctx
->coded_height
)
486 && avcodec_check_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
))
487 || avctx
->channels
> SANE_NB_CHANNELS
) {
488 ret
= AVERROR(EINVAL
);
492 avctx
->codec
= codec
;
493 if ((avctx
->codec_type
== CODEC_TYPE_UNKNOWN
|| avctx
->codec_type
== codec
->type
) &&
494 avctx
->codec_id
== CODEC_ID_NONE
) {
495 avctx
->codec_type
= codec
->type
;
496 avctx
->codec_id
= codec
->id
;
498 if(avctx
->codec_id
!= codec
->id
|| avctx
->codec_type
!= codec
->type
){
499 av_log(avctx
, AV_LOG_ERROR
, "codec type or id mismatches\n");
502 avctx
->frame_number
= 0;
503 if(avctx
->codec
->init
){
504 ret
= avctx
->codec
->init(avctx
);
511 entangled_thread_counter
--;
513 /* Release any user-supplied mutex. */
515 (*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_RELEASE
);
519 av_freep(&avctx
->priv_data
);
524 int attribute_align_arg
avcodec_encode_audio(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
525 const short *samples
)
527 if(buf_size
< FF_MIN_BUFFER_SIZE
&& 0){
528 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
531 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || samples
){
532 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, samples
);
533 avctx
->frame_number
++;
539 int attribute_align_arg
avcodec_encode_video(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
542 if(buf_size
< FF_MIN_BUFFER_SIZE
){
543 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
546 if(avcodec_check_dimensions(avctx
,avctx
->width
,avctx
->height
))
548 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || pict
){
549 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, pict
);
550 avctx
->frame_number
++;
551 emms_c(); //needed to avoid an emms_c() call before every return;
558 int avcodec_encode_subtitle(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
559 const AVSubtitle
*sub
)
562 if(sub
->start_display_time
) {
563 av_log(avctx
, AV_LOG_ERROR
, "start_display_time must be 0.\n");
566 if(sub
->num_rects
== 0 || !sub
->rects
)
568 ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, sub
);
569 avctx
->frame_number
++;
573 #if LIBAVCODEC_VERSION_MAJOR < 53
574 int attribute_align_arg
avcodec_decode_video(AVCodecContext
*avctx
, AVFrame
*picture
,
575 int *got_picture_ptr
,
576 const uint8_t *buf
, int buf_size
)
579 av_init_packet(&avpkt
);
581 avpkt
.size
= buf_size
;
582 // HACK for CorePNG to decode as normal PNG by default
583 avpkt
.flags
= AV_PKT_FLAG_KEY
;
585 return avcodec_decode_video2(avctx
, picture
, got_picture_ptr
, &avpkt
);
589 int attribute_align_arg
avcodec_decode_video2(AVCodecContext
*avctx
, AVFrame
*picture
,
590 int *got_picture_ptr
,
596 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
))
598 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || avpkt
->size
){
599 ret
= avctx
->codec
->decode(avctx
, picture
, got_picture_ptr
,
602 emms_c(); //needed to avoid an emms_c() call before every return;
604 if (*got_picture_ptr
)
605 avctx
->frame_number
++;
612 #if LIBAVCODEC_VERSION_MAJOR < 53
613 int attribute_align_arg
avcodec_decode_audio2(AVCodecContext
*avctx
, int16_t *samples
,
615 const uint8_t *buf
, int buf_size
)
618 av_init_packet(&avpkt
);
620 avpkt
.size
= buf_size
;
622 return avcodec_decode_audio3(avctx
, samples
, frame_size_ptr
, &avpkt
);
626 int attribute_align_arg
avcodec_decode_audio3(AVCodecContext
*avctx
, int16_t *samples
,
632 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || avpkt
->size
){
633 //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
634 if(*frame_size_ptr
< AVCODEC_MAX_AUDIO_FRAME_SIZE
){
635 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
638 if(*frame_size_ptr
< FF_MIN_BUFFER_SIZE
||
639 *frame_size_ptr
< avctx
->channels
* avctx
->frame_size
* sizeof(int16_t)){
640 av_log(avctx
, AV_LOG_ERROR
, "buffer %d too small\n", *frame_size_ptr
);
644 ret
= avctx
->codec
->decode(avctx
, samples
, frame_size_ptr
, avpkt
);
645 avctx
->frame_number
++;
653 #if LIBAVCODEC_VERSION_MAJOR < 53
654 int avcodec_decode_subtitle(AVCodecContext
*avctx
, AVSubtitle
*sub
,
656 const uint8_t *buf
, int buf_size
)
659 av_init_packet(&avpkt
);
661 avpkt
.size
= buf_size
;
663 return avcodec_decode_subtitle2(avctx
, sub
, got_sub_ptr
, &avpkt
);
667 int avcodec_decode_subtitle2(AVCodecContext
*avctx
, AVSubtitle
*sub
,
674 ret
= avctx
->codec
->decode(avctx
, sub
, got_sub_ptr
, avpkt
);
676 avctx
->frame_number
++;
680 int avcodec_close(AVCodecContext
*avctx
)
682 /* If there is a user-supplied mutex locking routine, call it. */
684 if ((*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_OBTAIN
))
688 entangled_thread_counter
++;
689 if(entangled_thread_counter
!= 1){
690 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
691 entangled_thread_counter
--;
695 if (HAVE_THREADS
&& avctx
->thread_opaque
)
696 avcodec_thread_free(avctx
);
697 if (avctx
->codec
->close
)
698 avctx
->codec
->close(avctx
);
699 avcodec_default_free_buffers(avctx
);
700 av_freep(&avctx
->priv_data
);
702 entangled_thread_counter
--;
704 /* Release any user-supplied mutex. */
706 (*ff_lockmgr_cb
)(&codec_mutex
, AV_LOCK_RELEASE
);
711 AVCodec
*avcodec_find_encoder(enum CodecID id
)
716 if (p
->encode
!= NULL
&& p
->id
== id
)
723 AVCodec
*avcodec_find_encoder_by_name(const char *name
)
730 if (p
->encode
!= NULL
&& strcmp(name
,p
->name
) == 0)
737 AVCodec
*avcodec_find_decoder(enum CodecID id
)
742 if (p
->decode
!= NULL
&& p
->id
== id
)
749 AVCodec
*avcodec_find_decoder_by_name(const char *name
)
756 if (p
->decode
!= NULL
&& strcmp(name
,p
->name
) == 0)
763 void avcodec_string(char *buf
, int buf_size
, AVCodecContext
*enc
, int encode
)
765 const char *codec_name
;
769 AVRational display_aspect_ratio
;
772 p
= avcodec_find_encoder(enc
->codec_id
);
774 p
= avcodec_find_decoder(enc
->codec_id
);
777 codec_name
= p
->name
;
778 } else if (enc
->codec_id
== CODEC_ID_MPEG2TS
) {
779 /* fake mpeg2 transport stream codec (currently not
781 codec_name
= "mpeg2ts";
782 } else if (enc
->codec_name
[0] != '\0') {
783 codec_name
= enc
->codec_name
;
785 /* output avi tags */
786 if( isprint(enc
->codec_tag
&0xFF) && isprint((enc
->codec_tag
>>8)&0xFF)
787 && isprint((enc
->codec_tag
>>16)&0xFF) && isprint((enc
->codec_tag
>>24)&0xFF)){
788 snprintf(buf1
, sizeof(buf1
), "%c%c%c%c / 0x%04X",
789 enc
->codec_tag
& 0xff,
790 (enc
->codec_tag
>> 8) & 0xff,
791 (enc
->codec_tag
>> 16) & 0xff,
792 (enc
->codec_tag
>> 24) & 0xff,
795 snprintf(buf1
, sizeof(buf1
), "0x%04x", enc
->codec_tag
);
800 switch(enc
->codec_type
) {
801 case CODEC_TYPE_VIDEO
:
802 snprintf(buf
, buf_size
,
804 codec_name
, enc
->mb_decision
? " (hq)" : "");
805 if (enc
->pix_fmt
!= PIX_FMT_NONE
) {
806 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
808 avcodec_get_pix_fmt_name(enc
->pix_fmt
));
811 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
813 enc
->width
, enc
->height
);
814 if (enc
->sample_aspect_ratio
.num
) {
815 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
816 enc
->width
*enc
->sample_aspect_ratio
.num
,
817 enc
->height
*enc
->sample_aspect_ratio
.den
,
819 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
820 " [PAR %d:%d DAR %d:%d]",
821 enc
->sample_aspect_ratio
.num
, enc
->sample_aspect_ratio
.den
,
822 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
824 if(av_log_get_level() >= AV_LOG_DEBUG
){
825 int g
= av_gcd(enc
->time_base
.num
, enc
->time_base
.den
);
826 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
828 enc
->time_base
.num
/g
, enc
->time_base
.den
/g
);
832 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
833 ", q=%d-%d", enc
->qmin
, enc
->qmax
);
835 bitrate
= enc
->bit_rate
;
837 case CODEC_TYPE_AUDIO
:
838 snprintf(buf
, buf_size
,
841 if (enc
->sample_rate
) {
842 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
843 ", %d Hz", enc
->sample_rate
);
845 av_strlcat(buf
, ", ", buf_size
);
846 avcodec_get_channel_layout_string(buf
+ strlen(buf
), buf_size
- strlen(buf
), enc
->channels
, enc
->channel_layout
);
847 if (enc
->sample_fmt
!= SAMPLE_FMT_NONE
) {
848 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
849 ", %s", avcodec_get_sample_fmt_name(enc
->sample_fmt
));
852 /* for PCM codecs, compute bitrate directly */
853 switch(enc
->codec_id
) {
854 case CODEC_ID_PCM_F64BE
:
855 case CODEC_ID_PCM_F64LE
:
856 bitrate
= enc
->sample_rate
* enc
->channels
* 64;
858 case CODEC_ID_PCM_S32LE
:
859 case CODEC_ID_PCM_S32BE
:
860 case CODEC_ID_PCM_U32LE
:
861 case CODEC_ID_PCM_U32BE
:
862 case CODEC_ID_PCM_F32BE
:
863 case CODEC_ID_PCM_F32LE
:
864 bitrate
= enc
->sample_rate
* enc
->channels
* 32;
866 case CODEC_ID_PCM_S24LE
:
867 case CODEC_ID_PCM_S24BE
:
868 case CODEC_ID_PCM_U24LE
:
869 case CODEC_ID_PCM_U24BE
:
870 case CODEC_ID_PCM_S24DAUD
:
871 bitrate
= enc
->sample_rate
* enc
->channels
* 24;
873 case CODEC_ID_PCM_S16LE
:
874 case CODEC_ID_PCM_S16BE
:
875 case CODEC_ID_PCM_S16LE_PLANAR
:
876 case CODEC_ID_PCM_U16LE
:
877 case CODEC_ID_PCM_U16BE
:
878 bitrate
= enc
->sample_rate
* enc
->channels
* 16;
880 case CODEC_ID_PCM_S8
:
881 case CODEC_ID_PCM_U8
:
882 case CODEC_ID_PCM_ALAW
:
883 case CODEC_ID_PCM_MULAW
:
884 case CODEC_ID_PCM_ZORK
:
885 bitrate
= enc
->sample_rate
* enc
->channels
* 8;
888 bitrate
= enc
->bit_rate
;
892 case CODEC_TYPE_DATA
:
893 snprintf(buf
, buf_size
, "Data: %s", codec_name
);
894 bitrate
= enc
->bit_rate
;
896 case CODEC_TYPE_SUBTITLE
:
897 snprintf(buf
, buf_size
, "Subtitle: %s", codec_name
);
898 bitrate
= enc
->bit_rate
;
900 case CODEC_TYPE_ATTACHMENT
:
901 snprintf(buf
, buf_size
, "Attachment: %s", codec_name
);
902 bitrate
= enc
->bit_rate
;
905 snprintf(buf
, buf_size
, "Invalid Codec type %d", enc
->codec_type
);
909 if (enc
->flags
& CODEC_FLAG_PASS1
)
910 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
912 if (enc
->flags
& CODEC_FLAG_PASS2
)
913 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
917 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
918 ", %d kb/s", bitrate
/ 1000);
922 unsigned avcodec_version( void )
924 return LIBAVCODEC_VERSION_INT
;
927 void avcodec_init(void)
929 static int initialized
= 0;
931 if (initialized
!= 0)
935 dsputil_static_init();
938 void avcodec_flush_buffers(AVCodecContext
*avctx
)
940 if(avctx
->codec
->flush
)
941 avctx
->codec
->flush(avctx
);
944 void avcodec_default_free_buffers(AVCodecContext
*s
){
947 if(s
->internal_buffer
==NULL
) return;
949 if (s
->internal_buffer_count
)
950 av_log(s
, AV_LOG_WARNING
, "Found %i unreleased buffers!\n", s
->internal_buffer_count
);
951 for(i
=0; i
<INTERNAL_BUFFER_SIZE
; i
++){
952 InternalBuffer
*buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
954 av_freep(&buf
->base
[j
]);
958 av_freep(&s
->internal_buffer
);
960 s
->internal_buffer_count
=0;
963 char av_get_pict_type_char(int pict_type
){
965 case FF_I_TYPE
: return 'I';
966 case FF_P_TYPE
: return 'P';
967 case FF_B_TYPE
: return 'B';
968 case FF_S_TYPE
: return 'S';
969 case FF_SI_TYPE
:return 'i';
970 case FF_SP_TYPE
:return 'p';
971 case FF_BI_TYPE
:return 'b';
976 int av_get_bits_per_sample(enum CodecID codec_id
){
978 case CODEC_ID_ADPCM_SBPRO_2
:
980 case CODEC_ID_ADPCM_SBPRO_3
:
982 case CODEC_ID_ADPCM_SBPRO_4
:
983 case CODEC_ID_ADPCM_CT
:
985 case CODEC_ID_PCM_ALAW
:
986 case CODEC_ID_PCM_MULAW
:
987 case CODEC_ID_PCM_S8
:
988 case CODEC_ID_PCM_U8
:
989 case CODEC_ID_PCM_ZORK
:
991 case CODEC_ID_PCM_S16BE
:
992 case CODEC_ID_PCM_S16LE
:
993 case CODEC_ID_PCM_S16LE_PLANAR
:
994 case CODEC_ID_PCM_U16BE
:
995 case CODEC_ID_PCM_U16LE
:
997 case CODEC_ID_PCM_S24DAUD
:
998 case CODEC_ID_PCM_S24BE
:
999 case CODEC_ID_PCM_S24LE
:
1000 case CODEC_ID_PCM_U24BE
:
1001 case CODEC_ID_PCM_U24LE
:
1003 case CODEC_ID_PCM_S32BE
:
1004 case CODEC_ID_PCM_S32LE
:
1005 case CODEC_ID_PCM_U32BE
:
1006 case CODEC_ID_PCM_U32LE
:
1007 case CODEC_ID_PCM_F32BE
:
1008 case CODEC_ID_PCM_F32LE
:
1010 case CODEC_ID_PCM_F64BE
:
1011 case CODEC_ID_PCM_F64LE
:
1018 int av_get_bits_per_sample_format(enum SampleFormat sample_fmt
) {
1019 switch (sample_fmt
) {
1022 case SAMPLE_FMT_S16
:
1024 case SAMPLE_FMT_S32
:
1025 case SAMPLE_FMT_FLT
:
1027 case SAMPLE_FMT_DBL
:
1035 int avcodec_thread_init(AVCodecContext
*s
, int thread_count
){
1036 s
->thread_count
= thread_count
;
1041 unsigned int av_xiphlacing(unsigned char *s
, unsigned int v
)
1055 /* Wrapper to work around the lack of mkstemp() on mingw/cygin.
1056 * Also, tries to create file in /tmp first, if possible.
1057 * *prefix can be a character constant; *filename will be allocated internally.
1058 * Returns file descriptor of opened file (or -1 on error)
1059 * and opened file name in **filename. */
1060 int av_tempfile(char *prefix
, char **filename
) {
1063 *filename
= tempnam(".", prefix
);
1065 size_t len
= strlen(prefix
) + 12; /* room for "/tmp/" and "XXXXXX\0" */
1066 *filename
= av_malloc(len
);
1068 /* -----common section-----*/
1069 if (*filename
== NULL
) {
1070 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot allocate file name\n");
1074 fd
= open(*filename
, O_RDWR
| O_BINARY
| O_CREAT
, 0444);
1076 snprintf(*filename
, len
, "/tmp/%sXXXXXX", prefix
);
1077 fd
= mkstemp(*filename
);
1079 snprintf(*filename
, len
, "./%sXXXXXX", prefix
);
1080 fd
= mkstemp(*filename
);
1083 /* -----common section-----*/
1085 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot open temporary file %s\n", *filename
);
1088 return fd
; /* success */
1094 } VideoFrameSizeAbbr
;
1098 int rate_num
, rate_den
;
1099 } VideoFrameRateAbbr
;
1101 static const VideoFrameSizeAbbr video_frame_size_abbrs
[] = {
1102 { "ntsc", 720, 480 },
1103 { "pal", 720, 576 },
1104 { "qntsc", 352, 240 }, /* VCD compliant NTSC */
1105 { "qpal", 352, 288 }, /* VCD compliant PAL */
1106 { "sntsc", 640, 480 }, /* square pixel NTSC */
1107 { "spal", 768, 576 }, /* square pixel PAL */
1108 { "film", 352, 240 },
1109 { "ntsc-film", 352, 240 },
1110 { "sqcif", 128, 96 },
1111 { "qcif", 176, 144 },
1112 { "cif", 352, 288 },
1113 { "4cif", 704, 576 },
1114 { "16cif", 1408,1152 },
1115 { "qqvga", 160, 120 },
1116 { "qvga", 320, 240 },
1117 { "vga", 640, 480 },
1118 { "svga", 800, 600 },
1119 { "xga", 1024, 768 },
1120 { "uxga", 1600,1200 },
1121 { "qxga", 2048,1536 },
1122 { "sxga", 1280,1024 },
1123 { "qsxga", 2560,2048 },
1124 { "hsxga", 5120,4096 },
1125 { "wvga", 852, 480 },
1126 { "wxga", 1366, 768 },
1127 { "wsxga", 1600,1024 },
1128 { "wuxga", 1920,1200 },
1129 { "woxga", 2560,1600 },
1130 { "wqsxga", 3200,2048 },
1131 { "wquxga", 3840,2400 },
1132 { "whsxga", 6400,4096 },
1133 { "whuxga", 7680,4800 },
1134 { "cga", 320, 200 },
1135 { "ega", 640, 350 },
1136 { "hd480", 852, 480 },
1137 { "hd720", 1280, 720 },
1138 { "hd1080", 1920,1080 },
1141 static const VideoFrameRateAbbr video_frame_rate_abbrs
[]= {
1142 { "ntsc", 30000, 1001 },
1144 { "qntsc", 30000, 1001 }, /* VCD compliant NTSC */
1145 { "qpal", 25, 1 }, /* VCD compliant PAL */
1146 { "sntsc", 30000, 1001 }, /* square pixel NTSC */
1147 { "spal", 25, 1 }, /* square pixel PAL */
1149 { "ntsc-film", 24000, 1001 },
1152 int av_parse_video_frame_size(int *width_ptr
, int *height_ptr
, const char *str
)
1155 int n
= FF_ARRAY_ELEMS(video_frame_size_abbrs
);
1157 int frame_width
= 0, frame_height
= 0;
1160 if (!strcmp(video_frame_size_abbrs
[i
].abbr
, str
)) {
1161 frame_width
= video_frame_size_abbrs
[i
].width
;
1162 frame_height
= video_frame_size_abbrs
[i
].height
;
1168 frame_width
= strtol(p
, &p
, 10);
1171 frame_height
= strtol(p
, &p
, 10);
1173 if (frame_width
<= 0 || frame_height
<= 0)
1175 *width_ptr
= frame_width
;
1176 *height_ptr
= frame_height
;
1180 int av_parse_video_frame_rate(AVRational
*frame_rate
, const char *arg
)
1183 int n
= FF_ARRAY_ELEMS(video_frame_rate_abbrs
);
1186 /* First, we check our abbreviation table */
1187 for (i
= 0; i
< n
; ++i
)
1188 if (!strcmp(video_frame_rate_abbrs
[i
].abbr
, arg
)) {
1189 frame_rate
->num
= video_frame_rate_abbrs
[i
].rate_num
;
1190 frame_rate
->den
= video_frame_rate_abbrs
[i
].rate_den
;
1194 /* Then, we try to parse it as fraction */
1195 cp
= strchr(arg
, '/');
1197 cp
= strchr(arg
, ':');
1200 frame_rate
->num
= strtol(arg
, &cpp
, 10);
1201 if (cpp
!= arg
|| cpp
== cp
)
1202 frame_rate
->den
= strtol(cp
+1, &cpp
, 10);
1204 frame_rate
->num
= 0;
1207 /* Finally we give up and parse it as double */
1208 AVRational time_base
= av_d2q(strtod(arg
, 0), 1001000);
1209 frame_rate
->den
= time_base
.den
;
1210 frame_rate
->num
= time_base
.num
;
1212 if (!frame_rate
->num
|| !frame_rate
->den
)
1218 void av_log_missing_feature(void *avc
, const char *feature
, int want_sample
)
1220 av_log(avc
, AV_LOG_WARNING
, "%s not implemented. Update your FFmpeg "
1221 "version to the newest one from SVN. If the problem still "
1222 "occurs, it means that your file has a feature which has not "
1223 "been implemented.", feature
);
1225 av_log_ask_for_sample(avc
, NULL
);
1227 av_log(avc
, AV_LOG_WARNING
, "\n");
1230 void av_log_ask_for_sample(void *avc
, const char *msg
)
1233 av_log(avc
, AV_LOG_WARNING
, "%s ", msg
);
1234 av_log(avc
, AV_LOG_WARNING
, "If you want to help, upload a sample "
1235 "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
1236 "and contact the ffmpeg-devel mailing list.\n");
1239 static AVHWAccel
*first_hwaccel
= NULL
;
1241 void av_register_hwaccel(AVHWAccel
*hwaccel
)
1243 AVHWAccel
**p
= &first_hwaccel
;
1247 hwaccel
->next
= NULL
;
1250 AVHWAccel
*av_hwaccel_next(AVHWAccel
*hwaccel
)
1252 return hwaccel
? hwaccel
->next
: first_hwaccel
;
1255 AVHWAccel
*ff_find_hwaccel(enum CodecID codec_id
, enum PixelFormat pix_fmt
)
1257 AVHWAccel
*hwaccel
=NULL
;
1259 while((hwaccel
= av_hwaccel_next(hwaccel
))){
1260 if ( hwaccel
->id
== codec_id
1261 && hwaccel
->pix_fmt
== pix_fmt
)
1267 int av_lockmgr_register(int (*cb
)(void **mutex
, enum AVLockOp op
))
1269 if (ff_lockmgr_cb
) {
1270 if (ff_lockmgr_cb(&codec_mutex
, AV_LOCK_DESTROY
))
1276 if (ff_lockmgr_cb
) {
1277 if (ff_lockmgr_cb(&codec_mutex
, AV_LOCK_CREATE
))