ppc chroma mess workaround (real bug is that the motion compensation code assumes...
[ffmpeg.git] / libavcodec / utils.c
1 /*
2  * utils for libavcodec
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>
6  *
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.
11  *
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.
16  *
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
20  */
21  
22 /**
23  * @file utils.c
24  * utils.
25  */
26  
27 #include "avcodec.h"
28 #include "dsputil.h"
29 #include "mpegvideo.h"
30 #include <stdarg.h>
31
32 void *av_mallocz(unsigned int size)
33 {
34     void *ptr;
35     
36     ptr = av_malloc(size);
37     if (!ptr)
38         return NULL;
39     memset(ptr, 0, size);
40     return ptr;
41 }
42
43 char *av_strdup(const char *s)
44 {
45     char *ptr;
46     int len;
47     len = strlen(s) + 1;
48     ptr = av_malloc(len);
49     if (!ptr)
50         return NULL;
51     memcpy(ptr, s, len);
52     return ptr;
53 }
54
55 /**
56  * realloc which does nothing if the block is large enough
57  */
58 void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
59 {
60     if(min_size < *size) 
61         return ptr;
62     
63     *size= min_size + 10*1024;
64
65     return av_realloc(ptr, *size);
66 }
67
68
69 /* allocation of static arrays - do not use for normal allocation */
70 static unsigned int last_static = 0;
71 static char*** array_static = NULL;
72 static const unsigned int grow_static = 64; // ^2
73 void *__av_mallocz_static(void** location, unsigned int size)
74 {
75     unsigned int l = (last_static + grow_static) & ~(grow_static - 1);
76     void *ptr = av_mallocz(size);
77     if (!ptr)
78         return NULL;
79
80     if (location)
81     {
82         if (l > last_static)
83             array_static = av_realloc(array_static, l);
84         array_static[last_static++] = (char**) location;
85         *location = ptr;
86     }
87     return ptr;
88 }
89 /* free all static arrays and reset pointers to 0 */
90 void av_free_static(void)
91 {
92     if (array_static)
93     {
94         unsigned i;
95         for (i = 0; i < last_static; i++)
96         {
97             av_free(*array_static[i]);
98             *array_static[i] = NULL;
99         }
100         av_free(array_static);
101         array_static = 0;
102     }
103     last_static = 0;
104 }
105
106 /* cannot call it directly because of 'void **' casting is not automatic */
107 void __av_freep(void **ptr)
108 {
109     av_free(*ptr);
110     *ptr = NULL;
111 }
112
113 /* encoder management */
114 AVCodec *first_avcodec;
115
116 void register_avcodec(AVCodec *format)
117 {
118     AVCodec **p;
119     p = &first_avcodec;
120     while (*p != NULL) p = &(*p)->next;
121     *p = format;
122     format->next = NULL;
123 }
124
125 typedef struct InternalBuffer{
126     int last_pic_num;
127     uint8_t *base[4];
128     uint8_t *data[4];
129     int linesize[4];
130 }InternalBuffer;
131
132 #define INTERNAL_BUFFER_SIZE 32
133
134 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
135
136 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
137     int w_align= 1;    
138     int h_align= 1;    
139     
140     switch(s->pix_fmt){
141     case PIX_FMT_YUV420P:
142     case PIX_FMT_YUV422:
143     case PIX_FMT_YUV422P:
144     case PIX_FMT_YUV444P:
145     case PIX_FMT_GRAY8:
146     case PIX_FMT_YUVJ420P:
147     case PIX_FMT_YUVJ422P:
148     case PIX_FMT_YUVJ444P:
149         w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
150         h_align= 16;
151         break;
152     case PIX_FMT_YUV411P:
153         w_align=32;
154         h_align=8;
155         break;
156     case PIX_FMT_YUV410P:
157         if(s->codec_id == CODEC_ID_SVQ1){
158             w_align=64;
159             h_align=64;
160         }
161         break;
162     default:
163         w_align= 1;
164         h_align= 1;
165         break;
166     }
167
168     *width = ALIGN(*width , w_align);
169     *height= ALIGN(*height, h_align);
170 }
171
172 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
173     int i;
174     int w= s->width;
175     int h= s->height;
176     InternalBuffer *buf;
177     int *picture_number;
178     
179     assert(pic->data[0]==NULL);
180     assert(INTERNAL_BUFFER_SIZE > s->internal_buffer_count);
181
182     if(s->internal_buffer==NULL){
183         s->internal_buffer= av_mallocz(INTERNAL_BUFFER_SIZE*sizeof(InternalBuffer));
184     }
185 #if 0
186     s->internal_buffer= av_fast_realloc(
187         s->internal_buffer, 
188         &s->internal_buffer_size, 
189         sizeof(InternalBuffer)*FFMAX(99,  s->internal_buffer_count+1)/*FIXME*/
190         );
191 #endif
192      
193     buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
194     picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE-1]).last_pic_num; //FIXME ugly hack
195     (*picture_number)++;
196     
197     if(buf->base[0]){
198         pic->age= *picture_number - buf->last_pic_num;
199         buf->last_pic_num= *picture_number;
200     }else{
201         int h_chroma_shift, v_chroma_shift;
202         int s_align, pixel_size;
203         
204         avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
205         
206         switch(s->pix_fmt){
207         case PIX_FMT_RGB555:
208         case PIX_FMT_RGB565:
209         case PIX_FMT_YUV422:
210             pixel_size=2;
211             break;
212         case PIX_FMT_RGB24:
213         case PIX_FMT_BGR24:
214             pixel_size=3;
215             break;
216         case PIX_FMT_RGBA32:
217             pixel_size=4;
218             break;
219         default:
220             pixel_size=1;
221         }
222
223         avcodec_align_dimensions(s, &w, &h);
224 #if defined(ARCH_POWERPC) || defined(HAVE_MMI) //FIXME some cleaner check
225         s_align= 16;
226 #else
227         s_align= 8;
228 #endif
229             
230         if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
231             w+= EDGE_WIDTH*2;
232             h+= EDGE_WIDTH*2;
233         }
234         
235         buf->last_pic_num= -256*256*256*64;
236
237         for(i=0; i<3; i++){
238             const int h_shift= i==0 ? 0 : h_chroma_shift;
239             const int v_shift= i==0 ? 0 : v_chroma_shift;
240
241             //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it
242             buf->linesize[i]= ALIGN(pixel_size*w>>h_shift, s_align<<(h_chroma_shift-h_shift)); 
243
244             buf->base[i]= av_mallocz((buf->linesize[i]*h>>v_shift)+16); //FIXME 16
245             if(buf->base[i]==NULL) return -1;
246             memset(buf->base[i], 128, buf->linesize[i]*h>>v_shift);
247         
248             if(s->flags&CODEC_FLAG_EMU_EDGE)
249                 buf->data[i] = buf->base[i];
250             else
251                 buf->data[i] = buf->base[i] + ALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), s_align);
252         }
253         pic->age= 256*256*256*64;
254     }
255     pic->type= FF_BUFFER_TYPE_INTERNAL;
256
257     for(i=0; i<4; i++){
258         pic->base[i]= buf->base[i];
259         pic->data[i]= buf->data[i];
260         pic->linesize[i]= buf->linesize[i];
261     }
262     s->internal_buffer_count++;
263
264     return 0;
265 }
266
267 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
268     int i;
269     InternalBuffer *buf, *last, temp;
270
271     assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
272     assert(s->internal_buffer_count);
273
274     buf = NULL; /* avoids warning */
275     for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
276         buf= &((InternalBuffer*)s->internal_buffer)[i];
277         if(buf->data[0] == pic->data[0])
278             break;
279     }
280     assert(i < s->internal_buffer_count);
281     s->internal_buffer_count--;
282     last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
283
284     temp= *buf;
285     *buf= *last;
286     *last= temp;
287
288     for(i=0; i<3; i++){
289         pic->data[i]=NULL;
290 //        pic->base[i]=NULL;
291     }
292 //printf("R%X\n", pic->opaque);
293 }
294
295 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
296     AVFrame temp_pic;
297     int i;
298
299     /* If no picture return a new buffer */
300     if(pic->data[0] == NULL) {
301         /* We will copy from buffer, so must be readable */
302         pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
303         return s->get_buffer(s, pic);
304     }
305
306     /* If internal buffer type return the same buffer */
307     if(pic->type == FF_BUFFER_TYPE_INTERNAL)
308         return 0;
309
310     /*
311      * Not internal type and reget_buffer not overridden, emulate cr buffer
312      */
313     temp_pic = *pic;
314     for(i = 0; i < 4; i++)
315         pic->data[i] = pic->base[i] = NULL;
316     pic->opaque = NULL;
317     /* Allocate new frame */
318     if (s->get_buffer(s, pic))
319         return -1;
320     /* Copy image data from old buffer to new buffer */
321     img_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
322              s->height);
323     s->release_buffer(s, &temp_pic); // Release old frame
324     return 0;
325 }
326
327 enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, enum PixelFormat * fmt){
328     return fmt[0];
329 }
330
331 void avcodec_get_context_defaults(AVCodecContext *s){
332     s->bit_rate= 800*1000;
333     s->bit_rate_tolerance= s->bit_rate*10;
334     s->qmin= 2;
335     s->qmax= 31;
336     s->mb_qmin= 2;
337     s->mb_qmax= 31;
338     s->rc_eq= "tex^qComp";
339     s->qcompress= 0.5;
340     s->max_qdiff= 3;
341     s->b_quant_factor=1.25;
342     s->b_quant_offset=1.25;
343     s->i_quant_factor=-0.8;
344     s->i_quant_offset=0.0;
345     s->error_concealment= 3;
346     s->error_resilience= 1;
347     s->workaround_bugs= FF_BUG_AUTODETECT;
348     s->frame_rate_base= 1;
349     s->frame_rate = 25;
350     s->gop_size= 50;
351     s->me_method= ME_EPZS;
352     s->get_buffer= avcodec_default_get_buffer;
353     s->release_buffer= avcodec_default_release_buffer;
354     s->get_format= avcodec_default_get_format;
355     s->me_subpel_quality=8;
356     s->lmin= FF_QP2LAMBDA * s->qmin;
357     s->lmax= FF_QP2LAMBDA * s->qmax;
358     s->sample_aspect_ratio= (AVRational){0,1};
359     s->ildct_cmp= FF_CMP_VSAD;
360     
361     s->intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
362     s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
363     s->palctrl = NULL;
364     s->reget_buffer= avcodec_default_reget_buffer;
365 }
366
367 /**
368  * allocates a AVCodecContext and set it to defaults.
369  * this can be deallocated by simply calling free() 
370  */
371 AVCodecContext *avcodec_alloc_context(void){
372     AVCodecContext *avctx= av_mallocz(sizeof(AVCodecContext));
373     
374     if(avctx==NULL) return NULL;
375     
376     avcodec_get_context_defaults(avctx);
377     
378     return avctx;
379 }
380
381 /**
382  * allocates a AVPFrame and set it to defaults.
383  * this can be deallocated by simply calling free() 
384  */
385 AVFrame *avcodec_alloc_frame(void){
386     AVFrame *pic= av_mallocz(sizeof(AVFrame));
387     
388     return pic;
389 }
390
391 int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
392 {
393     int ret;
394
395     if(avctx->codec)
396         return -1;
397
398     avctx->codec = codec;
399     avctx->codec_id = codec->id;
400     avctx->frame_number = 0;
401     if (codec->priv_data_size > 0) {
402         avctx->priv_data = av_mallocz(codec->priv_data_size);
403         if (!avctx->priv_data) 
404             return -ENOMEM;
405     } else {
406         avctx->priv_data = NULL;
407     }
408     ret = avctx->codec->init(avctx);
409     if (ret < 0) {
410         av_freep(&avctx->priv_data);
411         return ret;
412     }
413     return 0;
414 }
415
416 int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
417                          const short *samples)
418 {
419     int ret;
420
421     ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
422     avctx->frame_number++;
423     return ret;
424 }
425
426 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
427                          const AVFrame *pict)
428 {
429     int ret;
430
431     ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
432     
433     emms_c(); //needed to avoid a emms_c() call before every return;
434
435     avctx->frame_number++;
436     return ret;
437 }
438
439 /** 
440  * decode a frame. 
441  * @param buf bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE larger then the actual read bytes
442  * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
443  * @param buf_size the size of the buffer in bytes
444  * @param got_picture_ptr zero if no frame could be decompressed, Otherwise, it is non zero
445  * @return -1 if error, otherwise return the number of
446  * bytes used. 
447  */
448 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
449                          int *got_picture_ptr,
450                          uint8_t *buf, int buf_size)
451 {
452     int ret;
453     
454     ret = avctx->codec->decode(avctx, picture, got_picture_ptr, 
455                                buf, buf_size);
456
457     emms_c(); //needed to avoid a emms_c() call before every return;
458     
459     if (*got_picture_ptr)                           
460         avctx->frame_number++;
461     return ret;
462 }
463
464 /* decode an audio frame. return -1 if error, otherwise return the
465    *number of bytes used. If no frame could be decompressed,
466    *frame_size_ptr is zero. Otherwise, it is the decompressed frame
467    *size in BYTES. */
468 int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, 
469                          int *frame_size_ptr,
470                          uint8_t *buf, int buf_size)
471 {
472     int ret;
473
474     ret = avctx->codec->decode(avctx, samples, frame_size_ptr, 
475                                buf, buf_size);
476     avctx->frame_number++;
477     return ret;
478 }
479
480 int avcodec_close(AVCodecContext *avctx)
481 {
482     if (avctx->codec->close)
483         avctx->codec->close(avctx);
484     av_freep(&avctx->priv_data);
485     avctx->codec = NULL;
486     return 0;
487 }
488
489 AVCodec *avcodec_find_encoder(enum CodecID id)
490 {
491     AVCodec *p;
492     p = first_avcodec;
493     while (p) {
494         if (p->encode != NULL && p->id == id)
495             return p;
496         p = p->next;
497     }
498     return NULL;
499 }
500
501 AVCodec *avcodec_find_encoder_by_name(const char *name)
502 {
503     AVCodec *p;
504     p = first_avcodec;
505     while (p) {
506         if (p->encode != NULL && strcmp(name,p->name) == 0)
507             return p;
508         p = p->next;
509     }
510     return NULL;
511 }
512
513 AVCodec *avcodec_find_decoder(enum CodecID id)
514 {
515     AVCodec *p;
516     p = first_avcodec;
517     while (p) {
518         if (p->decode != NULL && p->id == id)
519             return p;
520         p = p->next;
521     }
522     return NULL;
523 }
524
525 AVCodec *avcodec_find_decoder_by_name(const char *name)
526 {
527     AVCodec *p;
528     p = first_avcodec;
529     while (p) {
530         if (p->decode != NULL && strcmp(name,p->name) == 0)
531             return p;
532         p = p->next;
533     }
534     return NULL;
535 }
536
537 AVCodec *avcodec_find(enum CodecID id)
538 {
539     AVCodec *p;
540     p = first_avcodec;
541     while (p) {
542         if (p->id == id)
543             return p;
544         p = p->next;
545     }
546     return NULL;
547 }
548
549 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
550 {
551     const char *codec_name;
552     AVCodec *p;
553     char buf1[32];
554     char channels_str[100];
555     int bitrate;
556
557     if (encode)
558         p = avcodec_find_encoder(enc->codec_id);
559     else
560         p = avcodec_find_decoder(enc->codec_id);
561
562     if (p) {
563         codec_name = p->name;
564         if (!encode && enc->codec_id == CODEC_ID_MP3) {
565             if (enc->sub_id == 2)
566                 codec_name = "mp2";
567             else if (enc->sub_id == 1)
568                 codec_name = "mp1";
569         }
570     } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
571         /* fake mpeg2 transport stream codec (currently not
572            registered) */
573         codec_name = "mpeg2ts";
574     } else if (enc->codec_name[0] != '\0') {
575         codec_name = enc->codec_name;
576     } else {
577         /* output avi tags */
578         if (enc->codec_type == CODEC_TYPE_VIDEO) {
579             snprintf(buf1, sizeof(buf1), "%c%c%c%c", 
580                      enc->codec_tag & 0xff,
581                      (enc->codec_tag >> 8) & 0xff,
582                      (enc->codec_tag >> 16) & 0xff,
583                      (enc->codec_tag >> 24) & 0xff);
584         } else {
585             snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
586         }
587         codec_name = buf1;
588     }
589
590     switch(enc->codec_type) {
591     case CODEC_TYPE_VIDEO:
592         snprintf(buf, buf_size,
593                  "Video: %s%s",
594                  codec_name, enc->mb_decision ? " (hq)" : "");
595         if (enc->codec_id == CODEC_ID_RAWVIDEO) {
596             snprintf(buf + strlen(buf), buf_size - strlen(buf),
597                      ", %s",
598                      avcodec_get_pix_fmt_name(enc->pix_fmt));
599         }
600         if (enc->width) {
601             snprintf(buf + strlen(buf), buf_size - strlen(buf),
602                      ", %dx%d, %0.2f fps",
603                      enc->width, enc->height, 
604                      (float)enc->frame_rate / enc->frame_rate_base);
605         }
606         if (encode) {
607             snprintf(buf + strlen(buf), buf_size - strlen(buf),
608                      ", q=%d-%d", enc->qmin, enc->qmax);
609         }
610         bitrate = enc->bit_rate;
611         break;
612     case CODEC_TYPE_AUDIO:
613         snprintf(buf, buf_size,
614                  "Audio: %s",
615                  codec_name);
616         switch (enc->channels) {
617             case 1:
618                 strcpy(channels_str, "mono");
619                 break;
620             case 2:
621                 strcpy(channels_str, "stereo");
622                 break;
623             case 6:
624                 strcpy(channels_str, "5:1");
625                 break;
626             default:
627                 sprintf(channels_str, "%d channels", enc->channels);
628                 break;
629         }
630         if (enc->sample_rate) {
631             snprintf(buf + strlen(buf), buf_size - strlen(buf),
632                      ", %d Hz, %s",
633                      enc->sample_rate,
634                      channels_str);
635         }
636         
637         /* for PCM codecs, compute bitrate directly */
638         switch(enc->codec_id) {
639         case CODEC_ID_PCM_S16LE:
640         case CODEC_ID_PCM_S16BE:
641         case CODEC_ID_PCM_U16LE:
642         case CODEC_ID_PCM_U16BE:
643             bitrate = enc->sample_rate * enc->channels * 16;
644             break;
645         case CODEC_ID_PCM_S8:
646         case CODEC_ID_PCM_U8:
647         case CODEC_ID_PCM_ALAW:
648         case CODEC_ID_PCM_MULAW:
649             bitrate = enc->sample_rate * enc->channels * 8;
650             break;
651         default:
652             bitrate = enc->bit_rate;
653             break;
654         }
655         break;
656     case CODEC_TYPE_DATA:
657         snprintf(buf, buf_size, "Data: %s", codec_name);
658         bitrate = enc->bit_rate;
659         break;
660     default:
661         av_abort();
662     }
663     if (encode) {
664         if (enc->flags & CODEC_FLAG_PASS1)
665             snprintf(buf + strlen(buf), buf_size - strlen(buf),
666                      ", pass 1");
667         if (enc->flags & CODEC_FLAG_PASS2)
668             snprintf(buf + strlen(buf), buf_size - strlen(buf),
669                      ", pass 2");
670     }
671     if (bitrate != 0) {
672         snprintf(buf + strlen(buf), buf_size - strlen(buf), 
673                  ", %d kb/s", bitrate / 1000);
674     }
675 }
676
677 unsigned avcodec_version( void )
678 {
679   return LIBAVCODEC_VERSION_INT;
680 }
681
682 unsigned avcodec_build( void )
683 {
684   return LIBAVCODEC_BUILD;
685 }
686
687 /* must be called before any other functions */
688 void avcodec_init(void)
689 {
690     static int inited = 0;
691
692     if (inited != 0)
693         return;
694     inited = 1;
695
696     dsputil_static_init();
697 }
698
699 /**
700  * Flush buffers, should be called when seeking or when swicthing to a different stream.
701  */
702 void avcodec_flush_buffers(AVCodecContext *avctx)
703 {
704     if(avctx->codec->flush)
705         avctx->codec->flush(avctx);
706 }
707
708 void avcodec_default_free_buffers(AVCodecContext *s){
709     int i, j;
710
711     if(s->internal_buffer==NULL) return;
712     
713     for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
714         InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
715         for(j=0; j<4; j++){
716             av_freep(&buf->base[j]);
717             buf->data[j]= NULL;
718         }
719     }
720     av_freep(&s->internal_buffer);
721     
722     s->internal_buffer_count=0;
723 }
724
725 char av_get_pict_type_char(int pict_type){
726     switch(pict_type){
727     case I_TYPE: return 'I'; 
728     case P_TYPE: return 'P'; 
729     case B_TYPE: return 'B'; 
730     case S_TYPE: return 'S'; 
731     case SI_TYPE:return 'i'; 
732     case SP_TYPE:return 'p'; 
733     default:     return '?';
734     }
735 }
736
737 int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){
738     int exact=1, sign=0;
739     int64_t gcd;
740
741     assert(den != 0);
742
743     if(den < 0){
744         den= -den;
745         nom= -nom;
746     }
747     
748     if(nom < 0){
749         nom= -nom;
750         sign= 1;
751     }
752     
753     gcd = ff_gcd(nom, den);
754     nom /= gcd;
755     den /= gcd;
756     
757     if(nom > max || den > max){
758         AVRational a0={0,1}, a1={1,0};
759         exact=0;
760
761         for(;;){
762             int64_t x= nom / den;
763             int64_t a2n= x*a1.num + a0.num;
764             int64_t a2d= x*a1.den + a0.den;
765
766             if(a2n > max || a2d > max) break;
767
768             nom %= den;
769         
770             a0= a1;
771             a1= (AVRational){a2n, a2d};
772             if(nom==0) break;
773             x= nom; nom=den; den=x;
774         }
775         nom= a1.num;
776         den= a1.den;
777     }
778     
779     assert(ff_gcd(nom, den) == 1);
780     
781     if(sign) nom= -nom;
782     
783     *dst_nom = nom;
784     *dst_den = den;
785     
786     return exact;
787 }
788
789 int64_t av_rescale(int64_t a, int b, int c){
790     uint64_t h, l;
791     assert(c > 0);
792     assert(b >=0);
793     
794     if(a<0) return -av_rescale(-a, b, c);
795     
796     h= a>>32;
797     if(h==0) return a*b/c;
798     
799     l= a&0xFFFFFFFF;
800     l *= b;
801     h *= b;
802
803     l += (h%c)<<32;
804
805     return ((h/c)<<32) + l/c;
806 }
807
808 /* av_log API */
809
810 #ifdef AV_LOG_TRAP_PRINTF
811 #undef stderr
812 #undef fprintf
813 #endif
814
815 static int av_log_level = AV_LOG_DEBUG;
816
817 static void av_log_default_callback(AVCodecContext* avctx, int level, const char* fmt, va_list vl)
818 {
819     static int print_prefix=1;
820
821     if(level>av_log_level)
822             return;
823     if(avctx && print_prefix)
824         fprintf(stderr, "[%s @ %p]", avctx->codec ? avctx->codec->name : "?", avctx);
825         
826     print_prefix= strstr(fmt, "\n") != NULL;
827         
828     vfprintf(stderr, fmt, vl);
829 }
830
831 static void (*av_log_callback)(AVCodecContext*, int, const char*, va_list) = av_log_default_callback;
832
833 void av_log(AVCodecContext* avctx, int level, const char *fmt, ...)
834 {
835     va_list vl;
836     va_start(vl, fmt);
837     av_vlog(avctx, level, fmt, vl);
838     va_end(vl);
839 }
840
841 void av_vlog(AVCodecContext* avctx, int level, const char *fmt, va_list vl)
842 {
843     av_log_callback(avctx, level, fmt, vl);
844 }
845
846 int av_log_get_level(void)
847 {
848     return av_log_level;
849 }
850
851 void av_log_set_level(int level)
852 {
853     av_log_level = level;
854 }
855
856 void av_log_set_callback(void (*callback)(AVCodecContext*, int, const char*, va_list))
857 {
858     av_log_callback = callback;
859 }
860