thread mess check for avcodec_open/close()
[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 "integer.h"
31 #include <stdarg.h>
32 #include <limits.h>
33
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
39 };
40
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
50 };
51
52 const uint8_t ff_reverse[256]={
53 0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
54 0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
55 0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
56 0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
57 0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
58 0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
59 0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
60 0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
61 0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
62 0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
63 0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
64 0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
65 0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
66 0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
67 0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
68 0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
69 };
70
71 static int volatile entangled_thread_counter=0;
72
73 void avcodec_default_free_buffers(AVCodecContext *s);
74
75 void *av_mallocz(unsigned int size)
76 {
77     void *ptr;
78     
79     ptr = av_malloc(size);
80     if (!ptr)
81         return NULL;
82     memset(ptr, 0, size);
83     return ptr;
84 }
85
86 char *av_strdup(const char *s)
87 {
88     char *ptr;
89     int len;
90     len = strlen(s) + 1;
91     ptr = av_malloc(len);
92     if (!ptr)
93         return NULL;
94     memcpy(ptr, s, len);
95     return ptr;
96 }
97
98 /**
99  * realloc which does nothing if the block is large enough
100  */
101 void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
102 {
103     if(min_size < *size) 
104         return ptr;
105     
106     *size= FFMAX(17*min_size/16 + 32, min_size);
107
108     return av_realloc(ptr, *size);
109 }
110
111
112 static unsigned int last_static = 0;
113 static unsigned int allocated_static = 0;
114 static void** array_static = NULL;
115
116 /**
117  * allocation of static arrays - do not use for normal allocation.
118  */
119 void *av_mallocz_static(unsigned int size)
120 {
121     void *ptr = av_mallocz(size);
122
123     if(ptr){ 
124         array_static =av_fast_realloc(array_static, &allocated_static, sizeof(void*)*(last_static+1));
125         if(!array_static)
126             return NULL;
127         array_static[last_static++] = ptr;
128     }
129
130     return ptr;
131 }
132
133 /**
134  * same as above, but does realloc
135  */
136
137 void *av_realloc_static(void *ptr, unsigned int size)
138 {
139     int i;
140     if(!ptr)
141       return av_mallocz_static(size);
142     /* Look for the old ptr */
143     for(i = 0; i < last_static; i++) {
144         if(array_static[i] == ptr) {
145             array_static[i] = av_realloc(array_static[i], size);
146             return array_static[i];
147         }
148     }
149     return NULL;
150
151 }
152
153 /**
154  * free all static arrays and reset pointers to 0.
155  */
156 void av_free_static(void)
157 {
158     while(last_static){
159         av_freep(&array_static[--last_static]);
160     }
161     av_freep(&array_static);
162 }
163
164 /**
165  * Frees memory and sets the pointer to NULL.
166  * @param arg pointer to the pointer which should be freed
167  */
168 void av_freep(void *arg)
169 {
170     void **ptr= (void**)arg;
171     av_free(*ptr);
172     *ptr = NULL;
173 }
174
175 /* encoder management */
176 AVCodec *first_avcodec = NULL;
177
178 void register_avcodec(AVCodec *format)
179 {
180     AVCodec **p;
181     p = &first_avcodec;
182     while (*p != NULL) p = &(*p)->next;
183     *p = format;
184     format->next = NULL;
185 }
186
187 void avcodec_set_dimensions(AVCodecContext *s, int width, int height){
188     s->coded_width = width;
189     s->coded_height= height;
190     s->width = -((-width )>>s->lowres);
191     s->height= -((-height)>>s->lowres);
192 }
193
194 typedef struct InternalBuffer{
195     int last_pic_num;
196     uint8_t *base[4];
197     uint8_t *data[4];
198     int linesize[4];
199 }InternalBuffer;
200
201 #define INTERNAL_BUFFER_SIZE 32
202
203 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
204
205 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
206     int w_align= 1;    
207     int h_align= 1;    
208     
209     switch(s->pix_fmt){
210     case PIX_FMT_YUV420P:
211     case PIX_FMT_YUV422:
212     case PIX_FMT_UYVY422:
213     case PIX_FMT_YUV422P:
214     case PIX_FMT_YUV444P:
215     case PIX_FMT_GRAY8:
216     case PIX_FMT_YUVJ420P:
217     case PIX_FMT_YUVJ422P:
218     case PIX_FMT_YUVJ444P:
219         w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
220         h_align= 16;
221         break;
222     case PIX_FMT_YUV411P:
223     case PIX_FMT_UYVY411:
224         w_align=32;
225         h_align=8;
226         break;
227     case PIX_FMT_YUV410P:
228         if(s->codec_id == CODEC_ID_SVQ1){
229             w_align=64;
230             h_align=64;
231         }
232     case PIX_FMT_RGB555:
233         if(s->codec_id == CODEC_ID_RPZA){
234             w_align=4;
235             h_align=4;
236         }
237     case PIX_FMT_PAL8:
238         if(s->codec_id == CODEC_ID_SMC){
239             w_align=4;
240             h_align=4;
241         }
242         break;
243     case PIX_FMT_BGR24:
244         if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){
245             w_align=4;
246             h_align=4;
247         }
248         break;
249     default:
250         w_align= 1;
251         h_align= 1;
252         break;
253     }
254
255     *width = ALIGN(*width , w_align);
256     *height= ALIGN(*height, h_align);
257 }
258
259 int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){
260     if((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/4)
261         return 0;
262     
263     av_log(av_log_ctx, AV_LOG_ERROR, "picture size invalid (%ux%u)\n", w, h);
264     return -1;
265 }
266
267 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
268     int i;
269     int w= s->width;
270     int h= s->height;
271     InternalBuffer *buf;
272     int *picture_number;
273
274     assert(pic->data[0]==NULL);
275     assert(INTERNAL_BUFFER_SIZE > s->internal_buffer_count);
276
277     if(avcodec_check_dimensions(s,w,h))
278         return -1;
279
280     if(s->internal_buffer==NULL){
281         s->internal_buffer= av_mallocz(INTERNAL_BUFFER_SIZE*sizeof(InternalBuffer));
282     }
283 #if 0
284     s->internal_buffer= av_fast_realloc(
285         s->internal_buffer, 
286         &s->internal_buffer_size, 
287         sizeof(InternalBuffer)*FFMAX(99,  s->internal_buffer_count+1)/*FIXME*/
288         );
289 #endif
290      
291     buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
292     picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE-1]).last_pic_num; //FIXME ugly hack
293     (*picture_number)++;
294     
295     if(buf->base[0]){
296         pic->age= *picture_number - buf->last_pic_num;
297         buf->last_pic_num= *picture_number;
298     }else{
299         int h_chroma_shift, v_chroma_shift;
300         int pixel_size;
301         
302         avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
303         
304         switch(s->pix_fmt){
305         case PIX_FMT_RGB555:
306         case PIX_FMT_RGB565:
307         case PIX_FMT_YUV422:
308         case PIX_FMT_UYVY422:
309             pixel_size=2;
310             break;
311         case PIX_FMT_RGB24:
312         case PIX_FMT_BGR24:
313             pixel_size=3;
314             break;
315         case PIX_FMT_RGBA32:
316             pixel_size=4;
317             break;
318         default:
319             pixel_size=1;
320         }
321
322         avcodec_align_dimensions(s, &w, &h);
323             
324         if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
325             w+= EDGE_WIDTH*2;
326             h+= EDGE_WIDTH*2;
327         }
328         
329         buf->last_pic_num= -256*256*256*64;
330
331         for(i=0; i<3; i++){
332             const int h_shift= i==0 ? 0 : h_chroma_shift;
333             const int v_shift= i==0 ? 0 : v_chroma_shift;
334
335             //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it
336             buf->linesize[i]= ALIGN(pixel_size*w>>h_shift, STRIDE_ALIGN<<(h_chroma_shift-h_shift)); 
337
338             buf->base[i]= av_malloc((buf->linesize[i]*h>>v_shift)+16); //FIXME 16
339             if(buf->base[i]==NULL) return -1;
340             memset(buf->base[i], 128, buf->linesize[i]*h>>v_shift);
341         
342             if(s->flags&CODEC_FLAG_EMU_EDGE)
343                 buf->data[i] = buf->base[i];
344             else
345                 buf->data[i] = buf->base[i] + ALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), STRIDE_ALIGN);
346         }
347         pic->age= 256*256*256*64;
348     }
349     pic->type= FF_BUFFER_TYPE_INTERNAL;
350
351     for(i=0; i<4; i++){
352         pic->base[i]= buf->base[i];
353         pic->data[i]= buf->data[i];
354         pic->linesize[i]= buf->linesize[i];
355     }
356     s->internal_buffer_count++;
357
358     return 0;
359 }
360
361 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
362     int i;
363     InternalBuffer *buf, *last, temp;
364
365     assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
366     assert(s->internal_buffer_count);
367
368     buf = NULL; /* avoids warning */
369     for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
370         buf= &((InternalBuffer*)s->internal_buffer)[i];
371         if(buf->data[0] == pic->data[0])
372             break;
373     }
374     assert(i < s->internal_buffer_count);
375     s->internal_buffer_count--;
376     last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
377
378     temp= *buf;
379     *buf= *last;
380     *last= temp;
381
382     for(i=0; i<3; i++){
383         pic->data[i]=NULL;
384 //        pic->base[i]=NULL;
385     }
386 //printf("R%X\n", pic->opaque);
387 }
388
389 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
390     AVFrame temp_pic;
391     int i;
392
393     /* If no picture return a new buffer */
394     if(pic->data[0] == NULL) {
395         /* We will copy from buffer, so must be readable */
396         pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
397         return s->get_buffer(s, pic);
398     }
399
400     /* If internal buffer type return the same buffer */
401     if(pic->type == FF_BUFFER_TYPE_INTERNAL)
402         return 0;
403
404     /*
405      * Not internal type and reget_buffer not overridden, emulate cr buffer
406      */
407     temp_pic = *pic;
408     for(i = 0; i < 4; i++)
409         pic->data[i] = pic->base[i] = NULL;
410     pic->opaque = NULL;
411     /* Allocate new frame */
412     if (s->get_buffer(s, pic))
413         return -1;
414     /* Copy image data from old buffer to new buffer */
415     img_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
416              s->height);
417     s->release_buffer(s, &temp_pic); // Release old frame
418     return 0;
419 }
420
421 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count){
422     int i;
423
424     for(i=0; i<count; i++){
425         int r= func(c, arg[i]);
426         if(ret) ret[i]= r;
427     }
428     return 0;
429 }
430
431 enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt){
432     return fmt[0];
433 }
434
435 static const char* context_to_name(void* ptr) {
436     AVCodecContext *avc= ptr;
437
438     if(avc && avc->codec && avc->codec->name)
439         return avc->codec->name; 
440     else
441         return "NULL";
442 }
443
444 static AVClass av_codec_context_class = { "AVCodecContext", context_to_name };
445
446 void avcodec_get_context_defaults(AVCodecContext *s){
447     memset(s, 0, sizeof(AVCodecContext));
448
449     s->av_class= &av_codec_context_class;
450     s->bit_rate= 800*1000;
451     s->bit_rate_tolerance= s->bit_rate*10;
452     s->qmin= 2;
453     s->qmax= 31;
454     s->mb_lmin= FF_QP2LAMBDA * 2;
455     s->mb_lmax= FF_QP2LAMBDA * 31;
456     s->rc_eq= "tex^qComp";
457     s->qcompress= 0.5;
458     s->max_qdiff= 3;
459     s->b_quant_factor=1.25;
460     s->b_quant_offset=1.25;
461     s->i_quant_factor=-0.8;
462     s->i_quant_offset=0.0;
463     s->error_concealment= 3;
464     s->error_resilience= 1;
465     s->workaround_bugs= FF_BUG_AUTODETECT;
466     s->time_base= (AVRational){0,1};
467     s->gop_size= 50;
468     s->me_method= ME_EPZS;
469     s->get_buffer= avcodec_default_get_buffer;
470     s->release_buffer= avcodec_default_release_buffer;
471     s->get_format= avcodec_default_get_format;
472     s->execute= avcodec_default_execute;
473     s->thread_count=1;
474     s->me_subpel_quality=8;
475     s->lmin= FF_QP2LAMBDA * s->qmin;
476     s->lmax= FF_QP2LAMBDA * s->qmax;
477     s->sample_aspect_ratio= (AVRational){0,1};
478     s->ildct_cmp= FF_CMP_VSAD;
479     s->profile= FF_PROFILE_UNKNOWN;
480     s->level= FF_LEVEL_UNKNOWN;
481     s->me_penalty_compensation= 256;
482     s->pix_fmt= PIX_FMT_NONE;
483     
484     s->intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
485     s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
486     s->palctrl = NULL;
487     s->reget_buffer= avcodec_default_reget_buffer;
488 }
489
490 /**
491  * allocates a AVCodecContext and set it to defaults.
492  * this can be deallocated by simply calling free() 
493  */
494 AVCodecContext *avcodec_alloc_context(void){
495     AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
496     
497     if(avctx==NULL) return NULL;
498     
499     avcodec_get_context_defaults(avctx);
500     
501     return avctx;
502 }
503
504 void avcodec_get_frame_defaults(AVFrame *pic){
505     memset(pic, 0, sizeof(AVFrame));
506
507     pic->pts= AV_NOPTS_VALUE;
508     pic->key_frame= 1;
509 }
510
511 /**
512  * allocates a AVPFrame and set it to defaults.
513  * this can be deallocated by simply calling free() 
514  */
515 AVFrame *avcodec_alloc_frame(void){
516     AVFrame *pic= av_malloc(sizeof(AVFrame));
517     
518     if(pic==NULL) return NULL;
519     
520     avcodec_get_frame_defaults(pic);
521     
522     return pic;
523 }
524
525 int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
526 {
527     int ret= -1;
528     
529     entangled_thread_counter++;
530     if(entangled_thread_counter != 1){
531         av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
532         goto end;
533     }
534
535     if(avctx->codec)
536         goto end;
537
538     avctx->codec = codec;
539     avctx->codec_id = codec->id;
540     avctx->frame_number = 0;
541     if (codec->priv_data_size > 0) {
542         avctx->priv_data = av_mallocz(codec->priv_data_size);
543         if (!avctx->priv_data) 
544             goto end;
545     } else {
546         avctx->priv_data = NULL;
547     }
548
549     if(avctx->coded_width && avctx->coded_height)
550         avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
551     else if(avctx->width && avctx->height)
552         avcodec_set_dimensions(avctx, avctx->width, avctx->height);
553
554     if((avctx->coded_width||avctx->coded_height) && avcodec_check_dimensions(avctx,avctx->coded_width,avctx->coded_height)){
555         av_freep(&avctx->priv_data);
556         goto end;
557     }
558
559     ret = avctx->codec->init(avctx);
560     if (ret < 0) {
561         av_freep(&avctx->priv_data);
562         goto end;
563     }
564     ret=0;
565 end:
566     entangled_thread_counter--;
567     return ret;
568 }
569
570 int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
571                          const short *samples)
572 {
573     if(buf_size < FF_MIN_BUFFER_SIZE && 0){
574         av_log(avctx, AV_LOG_ERROR, "buffer smaller then minimum size\n");
575         return -1;
576     }
577     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){
578         int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
579         avctx->frame_number++;
580         return ret;
581     }else
582         return 0;
583 }
584
585 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
586                          const AVFrame *pict)
587 {
588     if(buf_size < FF_MIN_BUFFER_SIZE){
589         av_log(avctx, AV_LOG_ERROR, "buffer smaller then minimum size\n");
590         return -1;
591     }
592     if(avcodec_check_dimensions(avctx,avctx->width,avctx->height))
593         return -1;
594     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){
595         int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
596         avctx->frame_number++;
597         emms_c(); //needed to avoid an emms_c() call before every return;
598     
599         return ret;
600     }else
601         return 0;
602 }
603
604 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
605                             const AVSubtitle *sub)
606 {
607     int ret;
608     ret = avctx->codec->encode(avctx, buf, buf_size, (void *)sub);
609     avctx->frame_number++;
610     return ret;
611 }
612
613 /** 
614  * decode a frame. 
615  * @param buf bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE larger then the actual read bytes
616  * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
617  * @param buf_size the size of the buffer in bytes
618  * @param got_picture_ptr zero if no frame could be decompressed, Otherwise, it is non zero
619  * @return -1 if error, otherwise return the number of
620  * bytes used. 
621  */
622 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
623                          int *got_picture_ptr,
624                          uint8_t *buf, int buf_size)
625 {
626     int ret;
627     
628     *got_picture_ptr= 0;
629     if((avctx->coded_width||avctx->coded_height) && avcodec_check_dimensions(avctx,avctx->coded_width,avctx->coded_height))
630         return -1;
631     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || buf_size){
632         ret = avctx->codec->decode(avctx, picture, got_picture_ptr, 
633                                 buf, buf_size);
634
635         emms_c(); //needed to avoid an emms_c() call before every return;
636     
637         if (*got_picture_ptr)                           
638             avctx->frame_number++;
639     }else
640         ret= 0;
641
642     return ret;
643 }
644
645 /* decode an audio frame. return -1 if error, otherwise return the
646    *number of bytes used. If no frame could be decompressed,
647    *frame_size_ptr is zero. Otherwise, it is the decompressed frame
648    *size in BYTES. */
649 int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, 
650                          int *frame_size_ptr,
651                          uint8_t *buf, int buf_size)
652 {
653     int ret;
654
655     *frame_size_ptr= 0;
656     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || buf_size){
657         ret = avctx->codec->decode(avctx, samples, frame_size_ptr, 
658                                 buf, buf_size);
659         avctx->frame_number++;
660     }else
661         ret= 0;
662     return ret;
663 }
664
665 /* decode a subtitle message. return -1 if error, otherwise return the
666    *number of bytes used. If no subtitle could be decompressed,
667    *got_sub_ptr is zero. Otherwise, the subtitle is stored in *sub. */
668 int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
669                             int *got_sub_ptr,
670                             const uint8_t *buf, int buf_size)
671 {
672     int ret;
673
674     *got_sub_ptr = 0;
675     ret = avctx->codec->decode(avctx, sub, got_sub_ptr, 
676                                (uint8_t *)buf, buf_size);
677     if (*got_sub_ptr)
678         avctx->frame_number++;
679     return ret;
680 }
681
682 int avcodec_close(AVCodecContext *avctx)
683 {
684     entangled_thread_counter++;
685     if(entangled_thread_counter != 1){
686         av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
687         entangled_thread_counter--;
688         return -1;
689     }
690
691     if (avctx->codec->close)
692         avctx->codec->close(avctx);
693     avcodec_default_free_buffers(avctx);
694     av_freep(&avctx->priv_data);
695     avctx->codec = NULL;
696     entangled_thread_counter--;
697     return 0;
698 }
699
700 AVCodec *avcodec_find_encoder(enum CodecID id)
701 {
702     AVCodec *p;
703     p = first_avcodec;
704     while (p) {
705         if (p->encode != NULL && p->id == id)
706             return p;
707         p = p->next;
708     }
709     return NULL;
710 }
711
712 AVCodec *avcodec_find_encoder_by_name(const char *name)
713 {
714     AVCodec *p;
715     p = first_avcodec;
716     while (p) {
717         if (p->encode != NULL && strcmp(name,p->name) == 0)
718             return p;
719         p = p->next;
720     }
721     return NULL;
722 }
723
724 AVCodec *avcodec_find_decoder(enum CodecID id)
725 {
726     AVCodec *p;
727     p = first_avcodec;
728     while (p) {
729         if (p->decode != NULL && p->id == id)
730             return p;
731         p = p->next;
732     }
733     return NULL;
734 }
735
736 AVCodec *avcodec_find_decoder_by_name(const char *name)
737 {
738     AVCodec *p;
739     p = first_avcodec;
740     while (p) {
741         if (p->decode != NULL && strcmp(name,p->name) == 0)
742             return p;
743         p = p->next;
744     }
745     return NULL;
746 }
747
748 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
749 {
750     const char *codec_name;
751     AVCodec *p;
752     char buf1[32];
753     char channels_str[100];
754     int bitrate;
755
756     if (encode)
757         p = avcodec_find_encoder(enc->codec_id);
758     else
759         p = avcodec_find_decoder(enc->codec_id);
760
761     if (p) {
762         codec_name = p->name;
763         if (!encode && enc->codec_id == CODEC_ID_MP3) {
764             if (enc->sub_id == 2)
765                 codec_name = "mp2";
766             else if (enc->sub_id == 1)
767                 codec_name = "mp1";
768         }
769     } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
770         /* fake mpeg2 transport stream codec (currently not
771            registered) */
772         codec_name = "mpeg2ts";
773     } else if (enc->codec_name[0] != '\0') {
774         codec_name = enc->codec_name;
775     } else {
776         /* output avi tags */
777         if (enc->codec_type == CODEC_TYPE_VIDEO) {
778             snprintf(buf1, sizeof(buf1), "%c%c%c%c", 
779                      enc->codec_tag & 0xff,
780                      (enc->codec_tag >> 8) & 0xff,
781                      (enc->codec_tag >> 16) & 0xff,
782                      (enc->codec_tag >> 24) & 0xff);
783         } else {
784             snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
785         }
786         codec_name = buf1;
787     }
788
789     switch(enc->codec_type) {
790     case CODEC_TYPE_VIDEO:
791         snprintf(buf, buf_size,
792                  "Video: %s%s",
793                  codec_name, enc->mb_decision ? " (hq)" : "");
794         if (enc->pix_fmt != PIX_FMT_NONE) {
795             snprintf(buf + strlen(buf), buf_size - strlen(buf),
796                      ", %s",
797                      avcodec_get_pix_fmt_name(enc->pix_fmt));
798         }
799         if (enc->width) {
800             snprintf(buf + strlen(buf), buf_size - strlen(buf),
801                      ", %dx%d, %0.2f fps",
802                      enc->width, enc->height, 
803                      1/av_q2d(enc->time_base));
804         }
805         if (encode) {
806             snprintf(buf + strlen(buf), buf_size - strlen(buf),
807                      ", q=%d-%d", enc->qmin, enc->qmax);
808         }
809         bitrate = enc->bit_rate;
810         break;
811     case CODEC_TYPE_AUDIO:
812         snprintf(buf, buf_size,
813                  "Audio: %s",
814                  codec_name);
815         switch (enc->channels) {
816             case 1:
817                 strcpy(channels_str, "mono");
818                 break;
819             case 2:
820                 strcpy(channels_str, "stereo");
821                 break;
822             case 6:
823                 strcpy(channels_str, "5:1");
824                 break;
825             default:
826                 snprintf(channels_str, sizeof(channels_str), "%d channels", enc->channels);
827                 break;
828         }
829         if (enc->sample_rate) {
830             snprintf(buf + strlen(buf), buf_size - strlen(buf),
831                      ", %d Hz, %s",
832                      enc->sample_rate,
833                      channels_str);
834         }
835         
836         /* for PCM codecs, compute bitrate directly */
837         switch(enc->codec_id) {
838         case CODEC_ID_PCM_S16LE:
839         case CODEC_ID_PCM_S16BE:
840         case CODEC_ID_PCM_U16LE:
841         case CODEC_ID_PCM_U16BE:
842             bitrate = enc->sample_rate * enc->channels * 16;
843             break;
844         case CODEC_ID_PCM_S8:
845         case CODEC_ID_PCM_U8:
846         case CODEC_ID_PCM_ALAW:
847         case CODEC_ID_PCM_MULAW:
848             bitrate = enc->sample_rate * enc->channels * 8;
849             break;
850         default:
851             bitrate = enc->bit_rate;
852             break;
853         }
854         break;
855     case CODEC_TYPE_DATA:
856         snprintf(buf, buf_size, "Data: %s", codec_name);
857         bitrate = enc->bit_rate;
858         break;
859     case CODEC_TYPE_SUBTITLE:
860         snprintf(buf, buf_size, "Subtitle: %s", codec_name);
861         bitrate = enc->bit_rate;
862         break;
863     default:
864         snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
865         return;
866     }
867     if (encode) {
868         if (enc->flags & CODEC_FLAG_PASS1)
869             snprintf(buf + strlen(buf), buf_size - strlen(buf),
870                      ", pass 1");
871         if (enc->flags & CODEC_FLAG_PASS2)
872             snprintf(buf + strlen(buf), buf_size - strlen(buf),
873                      ", pass 2");
874     }
875     if (bitrate != 0) {
876         snprintf(buf + strlen(buf), buf_size - strlen(buf), 
877                  ", %d kb/s", bitrate / 1000);
878     }
879 }
880
881 unsigned avcodec_version( void )
882 {
883   return LIBAVCODEC_VERSION_INT;
884 }
885
886 unsigned avcodec_build( void )
887 {
888   return LIBAVCODEC_BUILD;
889 }
890
891 /* must be called before any other functions */
892 void avcodec_init(void)
893 {
894     static int inited = 0;
895
896     if (inited != 0)
897         return;
898     inited = 1;
899
900     dsputil_static_init();
901 }
902
903 /**
904  * Flush buffers, should be called when seeking or when swicthing to a different stream.
905  */
906 void avcodec_flush_buffers(AVCodecContext *avctx)
907 {
908     if(avctx->codec->flush)
909         avctx->codec->flush(avctx);
910 }
911
912 void avcodec_default_free_buffers(AVCodecContext *s){
913     int i, j;
914
915     if(s->internal_buffer==NULL) return;
916     
917     for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
918         InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
919         for(j=0; j<4; j++){
920             av_freep(&buf->base[j]);
921             buf->data[j]= NULL;
922         }
923     }
924     av_freep(&s->internal_buffer);
925     
926     s->internal_buffer_count=0;
927 }
928
929 char av_get_pict_type_char(int pict_type){
930     switch(pict_type){
931     case I_TYPE: return 'I'; 
932     case P_TYPE: return 'P'; 
933     case B_TYPE: return 'B'; 
934     case S_TYPE: return 'S'; 
935     case SI_TYPE:return 'i'; 
936     case SP_TYPE:return 'p'; 
937     default:     return '?';
938     }
939 }
940
941 int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){
942     AVRational a0={0,1}, a1={1,0};
943     int sign= (nom<0) ^ (den<0);
944     int64_t gcd= ff_gcd(ABS(nom), ABS(den));
945
946     nom = ABS(nom)/gcd;
947     den = ABS(den)/gcd;
948     if(nom<=max && den<=max){
949         a1= (AVRational){nom, den};
950         den=0;
951     }
952     
953     while(den){
954         int64_t x       = nom / den;
955         int64_t next_den= nom - den*x;
956         int64_t a2n= x*a1.num + a0.num;
957         int64_t a2d= x*a1.den + a0.den;
958
959         if(a2n > max || a2d > max) break;
960
961         a0= a1;
962         a1= (AVRational){a2n, a2d};
963         nom= den;
964         den= next_den;
965     }
966     assert(ff_gcd(a1.num, a1.den) == 1);
967     
968     *dst_nom = sign ? -a1.num : a1.num;
969     *dst_den = a1.den;
970     
971     return den==0;
972 }
973
974 int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd){
975     AVInteger ai;
976     int64_t r=0;
977     assert(c > 0);
978     assert(b >=0);
979     assert(rnd >=0 && rnd<=5 && rnd!=4);
980     
981     if(a<0 && a != INT64_MIN) return -av_rescale_rnd(-a, b, c, rnd ^ ((rnd>>1)&1)); 
982     
983     if(rnd==AV_ROUND_NEAR_INF) r= c/2;
984     else if(rnd&1)             r= c-1;
985
986     if(b<=INT_MAX && c<=INT_MAX){
987         if(a<=INT_MAX)
988             return (a * b + r)/c;
989         else
990             return a/c*b + (a%c*b + r)/c;
991     }
992     
993     ai= av_mul_i(av_int2i(a), av_int2i(b));
994     ai= av_add_i(ai, av_int2i(r));
995     
996     return av_i2int(av_div_i(ai, av_int2i(c)));
997 }
998
999 int64_t av_rescale(int64_t a, int64_t b, int64_t c){
1000     return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
1001 }
1002
1003 int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq){
1004     int64_t b= bq.num * (int64_t)cq.den;
1005     int64_t c= cq.num * (int64_t)bq.den;
1006     return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
1007 }
1008
1009 int64_t ff_gcd(int64_t a, int64_t b){
1010     if(b) return ff_gcd(b, a%b);
1011     else  return a;
1012 }
1013
1014 double av_int2dbl(int64_t v){
1015     if(v+v > 0xFFELLU<<52)
1016         return 0.0/0.0;
1017     return ldexp(((v&(1LL<<52)-1) + (1LL<<52)) * (v>>63|1), (v>>52&0x7FF)-1075);
1018 }
1019
1020 float av_int2flt(int32_t v){
1021     if(v+v > 0xFF000000U)
1022         return 0.0/0.0;
1023     return ldexp(((v&0x7FFFFF) + (1<<23)) * (v>>31|1), (v>>23&0xFF)-150);
1024 }
1025
1026 int64_t av_dbl2int(double d){
1027     int e;
1028     if     ( !d) return 0;
1029     else if(d-d) return 0x7FF0000000000000LL + ((int64_t)(d<0)<<63) + (d!=d);
1030     d= frexp(d, &e);
1031     return (int64_t)(d<0)<<63 | (e+1022LL)<<52 | (int64_t)((fabs(d)-0.5)*(1LL<<53));
1032 }
1033
1034 int32_t av_flt2int(float d){
1035     int e;
1036     if     ( !d) return 0;
1037     else if(d-d) return 0x7F800000 + ((d<0)<<31) + (d!=d);
1038     d= frexp(d, &e);
1039     return (d<0)<<31 | (e+126)<<23 | (int64_t)((fabs(d)-0.5)*(1<<24));
1040 }
1041
1042 /* av_log API */
1043
1044 static int av_log_level = AV_LOG_INFO;
1045
1046 static void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl)
1047 {
1048     static int print_prefix=1;
1049     AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
1050     if(level>av_log_level)
1051         return;
1052 #undef fprintf
1053     if(print_prefix && avc) {
1054             fprintf(stderr, "[%s @ %p]", avc->item_name(ptr), avc);
1055     }
1056 #define fprintf please_use_av_log
1057         
1058     print_prefix= strstr(fmt, "\n") != NULL;
1059         
1060     vfprintf(stderr, fmt, vl);
1061 }
1062
1063 static void (*av_log_callback)(void*, int, const char*, va_list) = av_log_default_callback;
1064
1065 void av_log(void* avcl, int level, const char *fmt, ...)
1066 {
1067     va_list vl;
1068     va_start(vl, fmt);
1069     av_vlog(avcl, level, fmt, vl);
1070     va_end(vl);
1071 }
1072
1073 void av_vlog(void* avcl, int level, const char *fmt, va_list vl)
1074 {
1075     av_log_callback(avcl, level, fmt, vl);
1076 }
1077
1078 int av_log_get_level(void)
1079 {
1080     return av_log_level;
1081 }
1082
1083 void av_log_set_level(int level)
1084 {
1085     av_log_level = level;
1086 }
1087
1088 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list))
1089 {
1090     av_log_callback = callback;
1091 }
1092
1093 #if !defined(HAVE_THREADS)
1094 int avcodec_thread_init(AVCodecContext *s, int thread_count){
1095     return -1;
1096 }
1097 #endif
1098
1099 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1100 {
1101     unsigned int n = 0;
1102
1103     while(v >= 0xff) {
1104         *s++ = 0xff;
1105         v -= 0xff;
1106         n++;
1107     }
1108     *s = v;
1109     n++;
1110     return n;
1111 }