3 * Copyright (c) 2001 Fabrice Bellard.
4 * Copyright (c) 2003 Michel Bardiaux for the av_log API
5 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #include "mpegvideo.h"
34 const uint8_t ff_sqrt_tab
[128]={
35 0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
36 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
37 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
38 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11
41 const uint8_t ff_log2_tab
[256]={
42 0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
43 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
44 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
45 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
46 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
47 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
48 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
49 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
52 void avcodec_default_free_buffers(AVCodecContext
*s
);
54 void *av_mallocz(unsigned int size
)
58 ptr
= av_malloc(size
);
65 char *av_strdup(const char *s
)
78 * realloc which does nothing if the block is large enough
80 void *av_fast_realloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
85 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
87 return av_realloc(ptr
, *size
);
91 static unsigned int last_static
= 0;
92 static unsigned int allocated_static
= 0;
93 static void** array_static
= NULL
;
96 * allocation of static arrays - do not use for normal allocation.
98 void *av_mallocz_static(unsigned int size
)
100 void *ptr
= av_mallocz(size
);
103 array_static
=av_fast_realloc(array_static
, &allocated_static
, sizeof(void*)*(last_static
+1));
106 array_static
[last_static
++] = ptr
;
113 * same as above, but does realloc
116 void *av_realloc_static(void *ptr
, unsigned int size
)
120 return av_mallocz_static(size
);
121 /* Look for the old ptr */
122 for(i
= 0; i
< last_static
; i
++) {
123 if(array_static
[i
] == ptr
) {
124 array_static
[i
] = av_realloc(array_static
[i
], size
);
125 return array_static
[i
];
133 * free all static arrays and reset pointers to 0.
135 void av_free_static(void)
138 av_freep(&array_static
[--last_static
]);
140 av_freep(&array_static
);
144 * Frees memory and sets the pointer to NULL.
145 * @param arg pointer to the pointer which should be freed
147 void av_freep(void *arg
)
149 void **ptr
= (void**)arg
;
154 /* encoder management */
155 AVCodec
*first_avcodec
= NULL
;
157 void register_avcodec(AVCodec
*format
)
161 while (*p
!= NULL
) p
= &(*p
)->next
;
166 void avcodec_set_dimensions(AVCodecContext
*s
, int width
, int height
){
167 s
->coded_width
= width
;
168 s
->coded_height
= height
;
169 s
->width
= -((-width
)>>s
->lowres
);
170 s
->height
= -((-height
)>>s
->lowres
);
173 typedef struct InternalBuffer
{
180 #define INTERNAL_BUFFER_SIZE 32
182 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
184 void avcodec_align_dimensions(AVCodecContext
*s
, int *width
, int *height
){
189 case PIX_FMT_YUV420P
:
191 case PIX_FMT_UYVY422
:
192 case PIX_FMT_YUV422P
:
193 case PIX_FMT_YUV444P
:
195 case PIX_FMT_YUVJ420P
:
196 case PIX_FMT_YUVJ422P
:
197 case PIX_FMT_YUVJ444P
:
198 w_align
= 16; //FIXME check for non mpeg style codecs and use less alignment
201 case PIX_FMT_YUV411P
:
202 case PIX_FMT_UYVY411
:
206 case PIX_FMT_YUV410P
:
207 if(s
->codec_id
== CODEC_ID_SVQ1
){
212 if(s
->codec_id
== CODEC_ID_RPZA
){
217 if(s
->codec_id
== CODEC_ID_SMC
){
223 if((s
->codec_id
== CODEC_ID_MSZH
) || (s
->codec_id
== CODEC_ID_ZLIB
)){
234 *width
= ALIGN(*width
, w_align
);
235 *height
= ALIGN(*height
, h_align
);
238 int avcodec_check_dimensions(void *av_log_ctx
, unsigned int w
, unsigned int h
){
239 if((int)w
>0 && (int)h
>0 && (w
+128)*(uint64_t)(h
+128) < INT_MAX
/4)
242 av_log(av_log_ctx
, AV_LOG_ERROR
, "picture size invalid (%ux%u)\n", w
, h
);
246 int avcodec_default_get_buffer(AVCodecContext
*s
, AVFrame
*pic
){
253 assert(pic
->data
[0]==NULL
);
254 assert(INTERNAL_BUFFER_SIZE
> s
->internal_buffer_count
);
256 if(avcodec_check_dimensions(s
,w
,h
))
259 if(s
->internal_buffer
==NULL
){
260 s
->internal_buffer
= av_mallocz(INTERNAL_BUFFER_SIZE
*sizeof(InternalBuffer
));
263 s
->internal_buffer
= av_fast_realloc(
265 &s
->internal_buffer_size
,
266 sizeof(InternalBuffer
)*FFMAX(99, s
->internal_buffer_count
+1)/*FIXME*/
270 buf
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
271 picture_number
= &(((InternalBuffer
*)s
->internal_buffer
)[INTERNAL_BUFFER_SIZE
-1]).last_pic_num
; //FIXME ugly hack
275 pic
->age
= *picture_number
- buf
->last_pic_num
;
276 buf
->last_pic_num
= *picture_number
;
278 int h_chroma_shift
, v_chroma_shift
;
281 avcodec_get_chroma_sub_sample(s
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
287 case PIX_FMT_UYVY422
:
301 avcodec_align_dimensions(s
, &w
, &h
);
303 if(!(s
->flags
&CODEC_FLAG_EMU_EDGE
)){
308 buf
->last_pic_num
= -256*256*256*64;
311 const int h_shift
= i
==0 ?
0 : h_chroma_shift
;
312 const int v_shift
= i
==0 ?
0 : v_chroma_shift
;
314 //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it
315 buf
->linesize
[i
]= ALIGN(pixel_size
*w
>>h_shift
, STRIDE_ALIGN
<<(h_chroma_shift
-h_shift
));
317 buf
->base
[i
]= av_mallocz((buf
->linesize
[i
]*h
>>v_shift
)+16); //FIXME 16
318 if(buf
->base
[i
]==NULL
) return -1;
319 memset(buf
->base
[i
], 128, buf
->linesize
[i
]*h
>>v_shift
);
321 if(s
->flags
&CODEC_FLAG_EMU_EDGE
)
322 buf
->data
[i
] = buf
->base
[i
];
324 buf
->data
[i
] = buf
->base
[i
] + ALIGN((buf
->linesize
[i
]*EDGE_WIDTH
>>v_shift
) + (EDGE_WIDTH
>>h_shift
), STRIDE_ALIGN
);
326 pic
->age
= 256*256*256*64;
328 pic
->type
= FF_BUFFER_TYPE_INTERNAL
;
331 pic
->base
[i
]= buf
->base
[i
];
332 pic
->data
[i
]= buf
->data
[i
];
333 pic
->linesize
[i
]= buf
->linesize
[i
];
335 s
->internal_buffer_count
++;
340 void avcodec_default_release_buffer(AVCodecContext
*s
, AVFrame
*pic
){
342 InternalBuffer
*buf
, *last
, temp
;
344 assert(pic
->type
==FF_BUFFER_TYPE_INTERNAL
);
345 assert(s
->internal_buffer_count
);
347 buf
= NULL
; /* avoids warning */
348 for(i
=0; i
<s
->internal_buffer_count
; i
++){ //just 3-5 checks so is not worth to optimize
349 buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
350 if(buf
->data
[0] == pic
->data
[0])
353 assert(i
< s
->internal_buffer_count
);
354 s
->internal_buffer_count
--;
355 last
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
363 // pic->base[i]=NULL;
365 //printf("R%X\n", pic->opaque);
368 int avcodec_default_reget_buffer(AVCodecContext
*s
, AVFrame
*pic
){
372 /* If no picture return a new buffer */
373 if(pic
->data
[0] == NULL
) {
374 /* We will copy from buffer, so must be readable */
375 pic
->buffer_hints
|= FF_BUFFER_HINTS_READABLE
;
376 return s
->get_buffer(s
, pic
);
379 /* If internal buffer type return the same buffer */
380 if(pic
->type
== FF_BUFFER_TYPE_INTERNAL
)
384 * Not internal type and reget_buffer not overridden, emulate cr buffer
387 for(i
= 0; i
< 4; i
++)
388 pic
->data
[i
] = pic
->base
[i
] = NULL
;
390 /* Allocate new frame */
391 if (s
->get_buffer(s
, pic
))
393 /* Copy image data from old buffer to new buffer */
394 img_copy((AVPicture
*)pic
, (AVPicture
*)&temp_pic
, s
->pix_fmt
, s
->width
,
396 s
->release_buffer(s
, &temp_pic
); // Release old frame
400 int avcodec_default_execute(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
),void **arg
, int *ret
, int count
){
403 for(i
=0; i
<count
; i
++){
404 int r
= func(c
, arg
[i
]);
410 enum PixelFormat
avcodec_default_get_format(struct AVCodecContext
*s
, const enum PixelFormat
* fmt
){
414 static const char* context_to_name(void* ptr
) {
415 AVCodecContext
*avc
= ptr
;
417 if(avc
&& avc
->codec
&& avc
->codec
->name
)
418 return avc
->codec
->name
;
423 static AVClass av_codec_context_class
= { "AVCodecContext", context_to_name
};
425 void avcodec_get_context_defaults(AVCodecContext
*s
){
426 memset(s
, 0, sizeof(AVCodecContext
));
428 s
->av_class
= &av_codec_context_class
;
429 s
->bit_rate
= 800*1000;
430 s
->bit_rate_tolerance
= s
->bit_rate
*10;
435 s
->rc_eq
= "tex^qComp";
438 s
->b_quant_factor
=1.25;
439 s
->b_quant_offset
=1.25;
440 s
->i_quant_factor
=-0.8;
441 s
->i_quant_offset
=0.0;
442 s
->error_concealment
= 3;
443 s
->error_resilience
= 1;
444 s
->workaround_bugs
= FF_BUG_AUTODETECT
;
445 s
->frame_rate_base
= 1;
448 s
->me_method
= ME_EPZS
;
449 s
->get_buffer
= avcodec_default_get_buffer
;
450 s
->release_buffer
= avcodec_default_release_buffer
;
451 s
->get_format
= avcodec_default_get_format
;
452 s
->execute
= avcodec_default_execute
;
454 s
->me_subpel_quality
=8;
455 s
->lmin
= FF_QP2LAMBDA
* s
->qmin
;
456 s
->lmax
= FF_QP2LAMBDA
* s
->qmax
;
457 s
->sample_aspect_ratio
= (AVRational
){0,1};
458 s
->ildct_cmp
= FF_CMP_VSAD
;
459 s
->profile
= FF_PROFILE_UNKNOWN
;
460 s
->level
= FF_LEVEL_UNKNOWN
;
462 s
->intra_quant_bias
= FF_DEFAULT_QUANT_BIAS
;
463 s
->inter_quant_bias
= FF_DEFAULT_QUANT_BIAS
;
465 s
->reget_buffer
= avcodec_default_reget_buffer
;
469 * allocates a AVCodecContext and set it to defaults.
470 * this can be deallocated by simply calling free()
472 AVCodecContext
*avcodec_alloc_context(void){
473 AVCodecContext
*avctx
= av_malloc(sizeof(AVCodecContext
));
475 if(avctx
==NULL
) return NULL
;
477 avcodec_get_context_defaults(avctx
);
482 void avcodec_get_frame_defaults(AVFrame
*pic
){
483 memset(pic
, 0, sizeof(AVFrame
));
485 pic
->pts
= AV_NOPTS_VALUE
;
489 * allocates a AVPFrame and set it to defaults.
490 * this can be deallocated by simply calling free()
492 AVFrame
*avcodec_alloc_frame(void){
493 AVFrame
*pic
= av_malloc(sizeof(AVFrame
));
495 if(pic
==NULL
) return NULL
;
497 avcodec_get_frame_defaults(pic
);
502 int avcodec_open(AVCodecContext
*avctx
, AVCodec
*codec
)
509 avctx
->codec
= codec
;
510 avctx
->codec_id
= codec
->id
;
511 avctx
->frame_number
= 0;
512 if (codec
->priv_data_size
> 0) {
513 avctx
->priv_data
= av_mallocz(codec
->priv_data_size
);
514 if (!avctx
->priv_data
)
517 avctx
->priv_data
= NULL
;
520 if(avctx
->coded_width
&& avctx
->coded_height
)
521 avcodec_set_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
);
522 else if(avctx
->width
&& avctx
->height
)
523 avcodec_set_dimensions(avctx
, avctx
->width
, avctx
->height
);
525 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
)){
526 av_freep(&avctx
->priv_data
);
530 ret
= avctx
->codec
->init(avctx
);
532 av_freep(&avctx
->priv_data
);
538 int avcodec_encode_audio(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
539 const short *samples
)
541 if(buf_size
< FF_MIN_BUFFER_SIZE
&& 0){
542 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller then minimum size\n");
545 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || samples
){
546 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)samples
);
547 avctx
->frame_number
++;
553 int avcodec_encode_video(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
556 if(buf_size
< FF_MIN_BUFFER_SIZE
){
557 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller then minimum size\n");
560 if(avcodec_check_dimensions(avctx
,avctx
->width
,avctx
->height
))
562 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || pict
){
563 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)pict
);
564 avctx
->frame_number
++;
565 emms_c(); //needed to avoid a emms_c() call before every return;
574 * @param buf bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE larger then the actual read bytes
575 * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
576 * @param buf_size the size of the buffer in bytes
577 * @param got_picture_ptr zero if no frame could be decompressed, Otherwise, it is non zero
578 * @return -1 if error, otherwise return the number of
581 int avcodec_decode_video(AVCodecContext
*avctx
, AVFrame
*picture
,
582 int *got_picture_ptr
,
583 uint8_t *buf
, int buf_size
)
588 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
))
590 ret
= avctx
->codec
->decode(avctx
, picture
, got_picture_ptr
,
593 emms_c(); //needed to avoid a emms_c() call before every return;
595 if (*got_picture_ptr
)
596 avctx
->frame_number
++;
600 /* decode an audio frame. return -1 if error, otherwise return the
601 *number of bytes used. If no frame could be decompressed,
602 *frame_size_ptr is zero. Otherwise, it is the decompressed frame
604 int avcodec_decode_audio(AVCodecContext
*avctx
, int16_t *samples
,
606 uint8_t *buf
, int buf_size
)
611 ret
= avctx
->codec
->decode(avctx
, samples
, frame_size_ptr
,
613 avctx
->frame_number
++;
617 int avcodec_close(AVCodecContext
*avctx
)
619 if (avctx
->codec
->close
)
620 avctx
->codec
->close(avctx
);
621 avcodec_default_free_buffers(avctx
);
622 av_freep(&avctx
->priv_data
);
627 AVCodec
*avcodec_find_encoder(enum CodecID id
)
632 if (p
->encode
!= NULL
&& p
->id
== id
)
639 AVCodec
*avcodec_find_encoder_by_name(const char *name
)
644 if (p
->encode
!= NULL
&& strcmp(name
,p
->name
) == 0)
651 AVCodec
*avcodec_find_decoder(enum CodecID id
)
656 if (p
->decode
!= NULL
&& p
->id
== id
)
663 AVCodec
*avcodec_find_decoder_by_name(const char *name
)
668 if (p
->decode
!= NULL
&& strcmp(name
,p
->name
) == 0)
675 static AVCodec
*avcodec_find(enum CodecID id
)
687 void avcodec_string(char *buf
, int buf_size
, AVCodecContext
*enc
, int encode
)
689 const char *codec_name
;
692 char channels_str
[100];
696 p
= avcodec_find_encoder(enc
->codec_id
);
698 p
= avcodec_find_decoder(enc
->codec_id
);
701 codec_name
= p
->name
;
702 if (!encode
&& enc
->codec_id
== CODEC_ID_MP3
) {
703 if (enc
->sub_id
== 2)
705 else if (enc
->sub_id
== 1)
708 } else if (enc
->codec_id
== CODEC_ID_MPEG2TS
) {
709 /* fake mpeg2 transport stream codec (currently not
711 codec_name
= "mpeg2ts";
712 } else if (enc
->codec_name
[0] != '\0') {
713 codec_name
= enc
->codec_name
;
715 /* output avi tags */
716 if (enc
->codec_type
== CODEC_TYPE_VIDEO
) {
717 snprintf(buf1
, sizeof(buf1
), "%c%c%c%c",
718 enc
->codec_tag
& 0xff,
719 (enc
->codec_tag
>> 8) & 0xff,
720 (enc
->codec_tag
>> 16) & 0xff,
721 (enc
->codec_tag
>> 24) & 0xff);
723 snprintf(buf1
, sizeof(buf1
), "0x%04x", enc
->codec_tag
);
728 switch(enc
->codec_type
) {
729 case CODEC_TYPE_VIDEO
:
730 snprintf(buf
, buf_size
,
732 codec_name
, enc
->mb_decision ?
" (hq)" : "");
733 if (enc
->codec_id
== CODEC_ID_RAWVIDEO
) {
734 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
736 avcodec_get_pix_fmt_name(enc
->pix_fmt
));
739 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
740 ", %dx%d, %0.2f fps",
741 enc
->width
, enc
->height
,
742 (float)enc
->frame_rate
/ enc
->frame_rate_base
);
745 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
746 ", q=%d-%d", enc
->qmin
, enc
->qmax
);
748 bitrate
= enc
->bit_rate
;
750 case CODEC_TYPE_AUDIO
:
751 snprintf(buf
, buf_size
,
754 switch (enc
->channels
) {
756 strcpy(channels_str
, "mono");
759 strcpy(channels_str
, "stereo");
762 strcpy(channels_str
, "5:1");
765 sprintf(channels_str
, "%d channels", enc
->channels
);
768 if (enc
->sample_rate
) {
769 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
775 /* for PCM codecs, compute bitrate directly */
776 switch(enc
->codec_id
) {
777 case CODEC_ID_PCM_S16LE
:
778 case CODEC_ID_PCM_S16BE
:
779 case CODEC_ID_PCM_U16LE
:
780 case CODEC_ID_PCM_U16BE
:
781 bitrate
= enc
->sample_rate
* enc
->channels
* 16;
783 case CODEC_ID_PCM_S8
:
784 case CODEC_ID_PCM_U8
:
785 case CODEC_ID_PCM_ALAW
:
786 case CODEC_ID_PCM_MULAW
:
787 bitrate
= enc
->sample_rate
* enc
->channels
* 8;
790 bitrate
= enc
->bit_rate
;
794 case CODEC_TYPE_DATA
:
795 snprintf(buf
, buf_size
, "Data: %s", codec_name
);
796 bitrate
= enc
->bit_rate
;
799 snprintf(buf
, buf_size
, "Invalid Codec type %d", enc
->codec_type
);
803 if (enc
->flags
& CODEC_FLAG_PASS1
)
804 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
806 if (enc
->flags
& CODEC_FLAG_PASS2
)
807 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
811 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
812 ", %d kb/s", bitrate
/ 1000);
816 unsigned avcodec_version( void )
818 return LIBAVCODEC_VERSION_INT
;
821 unsigned avcodec_build( void )
823 return LIBAVCODEC_BUILD
;
826 /* must be called before any other functions */
827 void avcodec_init(void)
829 static int inited
= 0;
835 dsputil_static_init();
839 * Flush buffers, should be called when seeking or when swicthing to a different stream.
841 void avcodec_flush_buffers(AVCodecContext
*avctx
)
843 if(avctx
->codec
->flush
)
844 avctx
->codec
->flush(avctx
);
847 void avcodec_default_free_buffers(AVCodecContext
*s
){
850 if(s
->internal_buffer
==NULL
) return;
852 for(i
=0; i
<INTERNAL_BUFFER_SIZE
; i
++){
853 InternalBuffer
*buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
855 av_freep(&buf
->base
[j
]);
859 av_freep(&s
->internal_buffer
);
861 s
->internal_buffer_count
=0;
864 char av_get_pict_type_char(int pict_type
){
866 case I_TYPE
: return 'I';
867 case P_TYPE
: return 'P';
868 case B_TYPE
: return 'B';
869 case S_TYPE
: return 'S';
870 case SI_TYPE
:return 'i';
871 case SP_TYPE
:return 'p';
876 int av_reduce(int *dst_nom
, int *dst_den
, int64_t nom
, int64_t den
, int64_t max
){
877 AVRational a0
={0,1}, a1
={1,0};
878 int sign
= (nom
<0) ^ (den
<0);
879 int64_t gcd
= ff_gcd(ABS(nom
), ABS(den
));
883 if(nom
<=max
&& den
<=max
){
884 a1
= (AVRational
){nom
, den
};
889 int64_t x
= nom
/ den
;
890 int64_t next_den
= nom
- den
*x
;
891 int64_t a2n
= x
*a1
.num
+ a0
.num
;
892 int64_t a2d
= x
*a1
.den
+ a0
.den
;
894 if(a2n
> max
|| a2d
> max
) break;
897 a1
= (AVRational
){a2n
, a2d
};
901 assert(ff_gcd(a1
.num
, a1
.den
) == 1);
903 *dst_nom
= sign ?
-a1
.num
: a1
.num
;
909 int64_t av_rescale_rnd(int64_t a
, int64_t b
, int64_t c
, enum AVRounding rnd
){
914 assert(rnd
>=0 && rnd
<=5 && rnd
!=4);
916 if(a
<0 && a
!= INT64_MIN
) return -av_rescale_rnd(-a
, b
, c
, rnd
^ ((rnd
>>1)&1));
918 if(rnd
==AV_ROUND_NEAR_INF
) r
= c
/2;
919 else if(rnd
&1) r
= c
-1;
921 if(b
<=INT_MAX
&& c
<=INT_MAX
){
923 return (a
* b
+ r
)/c
;
925 return a
/c
*b
+ (a
%c
*b
+ r
)/c
;
928 ai
= av_mul_i(av_int2i(a
), av_int2i(b
));
929 ai
= av_add_i(ai
, av_int2i(r
));
931 return av_i2int(av_div_i(ai
, av_int2i(c
)));
934 int64_t av_rescale(int64_t a
, int64_t b
, int64_t c
){
935 return av_rescale_rnd(a
, b
, c
, AV_ROUND_NEAR_INF
);
938 int64_t ff_gcd(int64_t a
, int64_t b
){
939 if(b
) return ff_gcd(b
, a
%b
);
945 static int av_log_level
= AV_LOG_DEBUG
;
947 static void av_log_default_callback(void* ptr
, int level
, const char* fmt
, va_list vl
)
949 static int print_prefix
=1;
950 AVClass
* avc
= ptr ?
*(AVClass
**)ptr
: NULL
;
951 if(level
>av_log_level
)
954 if(print_prefix
&& avc
) {
955 fprintf(stderr
, "[%s @ %p]", avc
->item_name(ptr
), avc
);
957 #define fprintf please_use_av_log
959 print_prefix
= strstr(fmt
, "\n") != NULL
;
961 vfprintf(stderr
, fmt
, vl
);
964 static void (*av_log_callback
)(void*, int, const char*, va_list) = av_log_default_callback
;
966 void av_log(void* avcl
, int level
, const char *fmt
, ...)
970 av_vlog(avcl
, level
, fmt
, vl
);
974 void av_vlog(void* avcl
, int level
, const char *fmt
, va_list vl
)
976 av_log_callback(avcl
, level
, fmt
, vl
);
979 int av_log_get_level(void)
984 void av_log_set_level(int level
)
986 av_log_level
= level
;
989 void av_log_set_callback(void (*callback
)(void*, int, const char*, va_list))
991 av_log_callback
= callback
;
994 #if !defined(HAVE_THREADS)
995 int avcodec_thread_init(AVCodecContext
*s
, int thread_count
){