Statistics
| Branch: | Revision:

ffmpeg / libavcodec / utils.c @ 83f8c0c3

History | View | Annotate | Download (21.5 KB)

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
            buf->linesize[i]= ALIGN(pixel_size*w>>h_shift, s_align);
242

    
243
            buf->base[i]= av_mallocz((buf->linesize[i]*h>>v_shift)+16); //FIXME 16
244
            if(buf->base[i]==NULL) return -1;
245
            memset(buf->base[i], 128, buf->linesize[i]*h>>v_shift);
246
        
247
            if(s->flags&CODEC_FLAG_EMU_EDGE)
248
                buf->data[i] = buf->base[i];
249
            else
250
                buf->data[i] = buf->base[i] + ALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), s_align);
251
        }
252
        pic->age= 256*256*256*64;
253
    }
254
    pic->type= FF_BUFFER_TYPE_INTERNAL;
255

    
256
    for(i=0; i<4; i++){
257
        pic->base[i]= buf->base[i];
258
        pic->data[i]= buf->data[i];
259
        pic->linesize[i]= buf->linesize[i];
260
    }
261
    s->internal_buffer_count++;
262

    
263
    return 0;
264
}
265

    
266
void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
267
    int i;
268
    InternalBuffer *buf, *last, temp;
269

    
270
    assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
271
    assert(s->internal_buffer_count);
272

    
273
    buf = NULL; /* avoids warning */
274
    for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
275
        buf= &((InternalBuffer*)s->internal_buffer)[i];
276
        if(buf->data[0] == pic->data[0])
277
            break;
278
    }
279
    assert(i < s->internal_buffer_count);
280
    s->internal_buffer_count--;
281
    last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
282

    
283
    temp= *buf;
284
    *buf= *last;
285
    *last= temp;
286

    
287
    for(i=0; i<3; i++){
288
        pic->data[i]=NULL;
289
//        pic->base[i]=NULL;
290
    }
291
//printf("R%X\n", pic->opaque);
292
}
293

    
294
int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
295
    AVFrame temp_pic;
296
    int i;
297

    
298
    /* If no picture return a new buffer */
299
    if(pic->data[0] == NULL) {
300
        /* We will copy from buffer, so must be readable */
301
        pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
302
        return s->get_buffer(s, pic);
303
    }
304

    
305
    /* If internal buffer type return the same buffer */
306
    if(pic->type == FF_BUFFER_TYPE_INTERNAL)
307
        return 0;
308

    
309
    /*
310
     * Not internal type and reget_buffer not overridden, emulate cr buffer
311
     */
312
    temp_pic = *pic;
313
    for(i = 0; i < 4; i++)
314
        pic->data[i] = pic->base[i] = NULL;
315
    pic->opaque = NULL;
316
    /* Allocate new frame */
317
    if (s->get_buffer(s, pic))
318
        return -1;
319
    /* Copy image data from old buffer to new buffer */
320
    img_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
321
             s->height);
322
    s->release_buffer(s, &temp_pic); // Release old frame
323
    return 0;
324
}
325

    
326
enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, enum PixelFormat * fmt){
327
    return fmt[0];
328
}
329

    
330
void avcodec_get_context_defaults(AVCodecContext *s){
331
    s->bit_rate= 800*1000;
332
    s->bit_rate_tolerance= s->bit_rate*10;
333
    s->qmin= 2;
334
    s->qmax= 31;
335
    s->mb_qmin= 2;
336
    s->mb_qmax= 31;
337
    s->rc_eq= "tex^qComp";
338
    s->qcompress= 0.5;
339
    s->max_qdiff= 3;
340
    s->b_quant_factor=1.25;
341
    s->b_quant_offset=1.25;
342
    s->i_quant_factor=-0.8;
343
    s->i_quant_offset=0.0;
344
    s->error_concealment= 3;
345
    s->error_resilience= 1;
346
    s->workaround_bugs= FF_BUG_AUTODETECT;
347
    s->frame_rate_base= 1;
348
    s->frame_rate = 25;
349
    s->gop_size= 50;
350
    s->me_method= ME_EPZS;
351
    s->get_buffer= avcodec_default_get_buffer;
352
    s->release_buffer= avcodec_default_release_buffer;
353
    s->get_format= avcodec_default_get_format;
354
    s->me_subpel_quality=8;
355
    s->lmin= FF_QP2LAMBDA * s->qmin;
356
    s->lmax= FF_QP2LAMBDA * s->qmax;
357
    s->sample_aspect_ratio= (AVRational){0,1};
358
    s->ildct_cmp= FF_CMP_VSAD;
359
    
360
    s->intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
361
    s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
362
    s->palctrl = NULL;
363
    s->reget_buffer= avcodec_default_reget_buffer;
364
}
365

    
366
/**
367
 * allocates a AVCodecContext and set it to defaults.
368
 * this can be deallocated by simply calling free() 
369
 */
370
AVCodecContext *avcodec_alloc_context(void){
371
    AVCodecContext *avctx= av_mallocz(sizeof(AVCodecContext));
372
    
373
    if(avctx==NULL) return NULL;
374
    
375
    avcodec_get_context_defaults(avctx);
376
    
377
    return avctx;
378
}
379

    
380
/**
381
 * allocates a AVPFrame and set it to defaults.
382
 * this can be deallocated by simply calling free() 
383
 */
384
AVFrame *avcodec_alloc_frame(void){
385
    AVFrame *pic= av_mallocz(sizeof(AVFrame));
386
    
387
    return pic;
388
}
389

    
390
int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
391
{
392
    int ret;
393

    
394
    if(avctx->codec)
395
        return -1;
396

    
397
    avctx->codec = codec;
398
    avctx->codec_id = codec->id;
399
    avctx->frame_number = 0;
400
    if (codec->priv_data_size > 0) {
401
        avctx->priv_data = av_mallocz(codec->priv_data_size);
402
        if (!avctx->priv_data) 
403
            return -ENOMEM;
404
    } else {
405
        avctx->priv_data = NULL;
406
    }
407
    ret = avctx->codec->init(avctx);
408
    if (ret < 0) {
409
        av_freep(&avctx->priv_data);
410
        return ret;
411
    }
412
    return 0;
413
}
414

    
415
int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
416
                         const short *samples)
417
{
418
    int ret;
419

    
420
    ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
421
    avctx->frame_number++;
422
    return ret;
423
}
424

    
425
int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
426
                         const AVFrame *pict)
427
{
428
    int ret;
429

    
430
    ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
431
    
432
    emms_c(); //needed to avoid a emms_c() call before every return;
433

    
434
    avctx->frame_number++;
435
    return ret;
436
}
437

    
438
/** 
439
 * decode a frame. 
440
 * @param buf bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE larger then the actual read bytes
441
 * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
442
 * @param buf_size the size of the buffer in bytes
443
 * @param got_picture_ptr zero if no frame could be decompressed, Otherwise, it is non zero
444
 * @return -1 if error, otherwise return the number of
445
 * bytes used. 
446
 */
447
int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
448
                         int *got_picture_ptr,
449
                         uint8_t *buf, int buf_size)
450
{
451
    int ret;
452
    
453
    ret = avctx->codec->decode(avctx, picture, got_picture_ptr, 
454
                               buf, buf_size);
455

    
456
    emms_c(); //needed to avoid a emms_c() call before every return;
457
    
458
    if (*got_picture_ptr)                           
459
        avctx->frame_number++;
460
    return ret;
461
}
462

    
463
/* decode an audio frame. return -1 if error, otherwise return the
464
   *number of bytes used. If no frame could be decompressed,
465
   *frame_size_ptr is zero. Otherwise, it is the decompressed frame
466
   *size in BYTES. */
467
int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, 
468
                         int *frame_size_ptr,
469
                         uint8_t *buf, int buf_size)
470
{
471
    int ret;
472

    
473
    ret = avctx->codec->decode(avctx, samples, frame_size_ptr, 
474
                               buf, buf_size);
475
    avctx->frame_number++;
476
    return ret;
477
}
478

    
479
int avcodec_close(AVCodecContext *avctx)
480
{
481
    if (avctx->codec->close)
482
        avctx->codec->close(avctx);
483
    av_freep(&avctx->priv_data);
484
    avctx->codec = NULL;
485
    return 0;
486
}
487

    
488
AVCodec *avcodec_find_encoder(enum CodecID id)
489
{
490
    AVCodec *p;
491
    p = first_avcodec;
492
    while (p) {
493
        if (p->encode != NULL && p->id == id)
494
            return p;
495
        p = p->next;
496
    }
497
    return NULL;
498
}
499

    
500
AVCodec *avcodec_find_encoder_by_name(const char *name)
501
{
502
    AVCodec *p;
503
    p = first_avcodec;
504
    while (p) {
505
        if (p->encode != NULL && strcmp(name,p->name) == 0)
506
            return p;
507
        p = p->next;
508
    }
509
    return NULL;
510
}
511

    
512
AVCodec *avcodec_find_decoder(enum CodecID id)
513
{
514
    AVCodec *p;
515
    p = first_avcodec;
516
    while (p) {
517
        if (p->decode != NULL && p->id == id)
518
            return p;
519
        p = p->next;
520
    }
521
    return NULL;
522
}
523

    
524
AVCodec *avcodec_find_decoder_by_name(const char *name)
525
{
526
    AVCodec *p;
527
    p = first_avcodec;
528
    while (p) {
529
        if (p->decode != NULL && strcmp(name,p->name) == 0)
530
            return p;
531
        p = p->next;
532
    }
533
    return NULL;
534
}
535

    
536
AVCodec *avcodec_find(enum CodecID id)
537
{
538
    AVCodec *p;
539
    p = first_avcodec;
540
    while (p) {
541
        if (p->id == id)
542
            return p;
543
        p = p->next;
544
    }
545
    return NULL;
546
}
547

    
548
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
549
{
550
    const char *codec_name;
551
    AVCodec *p;
552
    char buf1[32];
553
    char channels_str[100];
554
    int bitrate;
555

    
556
    if (encode)
557
        p = avcodec_find_encoder(enc->codec_id);
558
    else
559
        p = avcodec_find_decoder(enc->codec_id);
560

    
561
    if (p) {
562
        codec_name = p->name;
563
        if (!encode && enc->codec_id == CODEC_ID_MP3) {
564
            if (enc->sub_id == 2)
565
                codec_name = "mp2";
566
            else if (enc->sub_id == 1)
567
                codec_name = "mp1";
568
        }
569
    } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
570
        /* fake mpeg2 transport stream codec (currently not
571
           registered) */
572
        codec_name = "mpeg2ts";
573
    } else if (enc->codec_name[0] != '\0') {
574
        codec_name = enc->codec_name;
575
    } else {
576
        /* output avi tags */
577
        if (enc->codec_type == CODEC_TYPE_VIDEO) {
578
            snprintf(buf1, sizeof(buf1), "%c%c%c%c", 
579
                     enc->codec_tag & 0xff,
580
                     (enc->codec_tag >> 8) & 0xff,
581
                     (enc->codec_tag >> 16) & 0xff,
582
                     (enc->codec_tag >> 24) & 0xff);
583
        } else {
584
            snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
585
        }
586
        codec_name = buf1;
587
    }
588

    
589
    switch(enc->codec_type) {
590
    case CODEC_TYPE_VIDEO:
591
        snprintf(buf, buf_size,
592
                 "Video: %s%s",
593
                 codec_name, enc->mb_decision ? " (hq)" : "");
594
        if (enc->codec_id == CODEC_ID_RAWVIDEO) {
595
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
596
                     ", %s",
597
                     avcodec_get_pix_fmt_name(enc->pix_fmt));
598
        }
599
        if (enc->width) {
600
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
601
                     ", %dx%d, %0.2f fps",
602
                     enc->width, enc->height, 
603
                     (float)enc->frame_rate / enc->frame_rate_base);
604
        }
605
        if (encode) {
606
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
607
                     ", q=%d-%d", enc->qmin, enc->qmax);
608
        }
609
        bitrate = enc->bit_rate;
610
        break;
611
    case CODEC_TYPE_AUDIO:
612
        snprintf(buf, buf_size,
613
                 "Audio: %s",
614
                 codec_name);
615
        switch (enc->channels) {
616
            case 1:
617
                strcpy(channels_str, "mono");
618
                break;
619
            case 2:
620
                strcpy(channels_str, "stereo");
621
                break;
622
            case 6:
623
                strcpy(channels_str, "5:1");
624
                break;
625
            default:
626
                sprintf(channels_str, "%d channels", enc->channels);
627
                break;
628
        }
629
        if (enc->sample_rate) {
630
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
631
                     ", %d Hz, %s",
632
                     enc->sample_rate,
633
                     channels_str);
634
        }
635
        
636
        /* for PCM codecs, compute bitrate directly */
637
        switch(enc->codec_id) {
638
        case CODEC_ID_PCM_S16LE:
639
        case CODEC_ID_PCM_S16BE:
640
        case CODEC_ID_PCM_U16LE:
641
        case CODEC_ID_PCM_U16BE:
642
            bitrate = enc->sample_rate * enc->channels * 16;
643
            break;
644
        case CODEC_ID_PCM_S8:
645
        case CODEC_ID_PCM_U8:
646
        case CODEC_ID_PCM_ALAW:
647
        case CODEC_ID_PCM_MULAW:
648
            bitrate = enc->sample_rate * enc->channels * 8;
649
            break;
650
        default:
651
            bitrate = enc->bit_rate;
652
            break;
653
        }
654
        break;
655
    case CODEC_TYPE_DATA:
656
        snprintf(buf, buf_size, "Data: %s", codec_name);
657
        bitrate = enc->bit_rate;
658
        break;
659
    default:
660
        av_abort();
661
    }
662
    if (encode) {
663
        if (enc->flags & CODEC_FLAG_PASS1)
664
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
665
                     ", pass 1");
666
        if (enc->flags & CODEC_FLAG_PASS2)
667
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
668
                     ", pass 2");
669
    }
670
    if (bitrate != 0) {
671
        snprintf(buf + strlen(buf), buf_size - strlen(buf), 
672
                 ", %d kb/s", bitrate / 1000);
673
    }
674
}
675

    
676
unsigned avcodec_version( void )
677
{
678
  return LIBAVCODEC_VERSION_INT;
679
}
680

    
681
unsigned avcodec_build( void )
682
{
683
  return LIBAVCODEC_BUILD;
684
}
685

    
686
/* must be called before any other functions */
687
void avcodec_init(void)
688
{
689
    static int inited = 0;
690

    
691
    if (inited != 0)
692
        return;
693
    inited = 1;
694

    
695
    dsputil_static_init();
696
}
697

    
698
/**
699
 * Flush buffers, should be called when seeking or when swicthing to a different stream.
700
 */
701
void avcodec_flush_buffers(AVCodecContext *avctx)
702
{
703
    if(avctx->codec->flush)
704
        avctx->codec->flush(avctx);
705
}
706

    
707
void avcodec_default_free_buffers(AVCodecContext *s){
708
    int i, j;
709

    
710
    if(s->internal_buffer==NULL) return;
711
    
712
    for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
713
        InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
714
        for(j=0; j<4; j++){
715
            av_freep(&buf->base[j]);
716
            buf->data[j]= NULL;
717
        }
718
    }
719
    av_freep(&s->internal_buffer);
720
    
721
    s->internal_buffer_count=0;
722
}
723

    
724
char av_get_pict_type_char(int pict_type){
725
    switch(pict_type){
726
    case I_TYPE: return 'I'; 
727
    case P_TYPE: return 'P'; 
728
    case B_TYPE: return 'B'; 
729
    case S_TYPE: return 'S'; 
730
    case SI_TYPE:return 'i'; 
731
    case SP_TYPE:return 'p'; 
732
    default:     return '?';
733
    }
734
}
735

    
736
int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){
737
    int exact=1, sign=0;
738
    int64_t gcd;
739

    
740
    assert(den != 0);
741

    
742
    if(den < 0){
743
        den= -den;
744
        nom= -nom;
745
    }
746
    
747
    if(nom < 0){
748
        nom= -nom;
749
        sign= 1;
750
    }
751
    
752
    gcd = ff_gcd(nom, den);
753
    nom /= gcd;
754
    den /= gcd;
755
    
756
    if(nom > max || den > max){
757
        AVRational a0={0,1}, a1={1,0};
758
        exact=0;
759

    
760
        for(;;){
761
            int64_t x= nom / den;
762
            int64_t a2n= x*a1.num + a0.num;
763
            int64_t a2d= x*a1.den + a0.den;
764

    
765
            if(a2n > max || a2d > max) break;
766

    
767
            nom %= den;
768
        
769
            a0= a1;
770
            a1= (AVRational){a2n, a2d};
771
            if(nom==0) break;
772
            x= nom; nom=den; den=x;
773
        }
774
        nom= a1.num;
775
        den= a1.den;
776
    }
777
    
778
    assert(ff_gcd(nom, den) == 1);
779
    
780
    if(sign) nom= -nom;
781
    
782
    *dst_nom = nom;
783
    *dst_den = den;
784
    
785
    return exact;
786
}
787

    
788
int64_t av_rescale(int64_t a, int b, int c){
789
    uint64_t h, l;
790
    assert(c > 0);
791
    assert(b >=0);
792
    
793
    if(a<0) return -av_rescale(-a, b, c);
794
    
795
    h= a>>32;
796
    if(h==0) return a*b/c;
797
    
798
    l= a&0xFFFFFFFF;
799
    l *= b;
800
    h *= b;
801

    
802
    l += (h%c)<<32;
803

    
804
    return ((h/c)<<32) + l/c;
805
}
806

    
807
/* av_log API */
808

    
809
#ifdef AV_LOG_TRAP_PRINTF
810
#undef stderr
811
#undef fprintf
812
#endif
813

    
814
static int av_log_level = AV_LOG_DEBUG;
815

    
816
static void av_log_default_callback(AVCodecContext* avctx, int level, const char* fmt, va_list vl)
817
{
818
    static int print_prefix=1;
819

    
820
    if(level>av_log_level)
821
            return;
822
    if(avctx && print_prefix)
823
        fprintf(stderr, "[%s @ %p]", avctx->codec ? avctx->codec->name : "?", avctx);
824
        
825
    print_prefix= (int)strstr(fmt, "\n");
826
        
827
    vfprintf(stderr, fmt, vl);
828
}
829

    
830
static void (*av_log_callback)(AVCodecContext*, int, const char*, va_list) = av_log_default_callback;
831

    
832
void av_log(AVCodecContext* avctx, int level, const char *fmt, ...)
833
{
834
    va_list vl;
835
    va_start(vl, fmt);
836
    av_vlog(avctx, level, fmt, vl);
837
    va_end(vl);
838
}
839

    
840
void av_vlog(AVCodecContext* avctx, int level, const char *fmt, va_list vl)
841
{
842
    av_log_callback(avctx, level, fmt, vl);
843
}
844

    
845
int av_log_get_level(void)
846
{
847
    return av_log_level;
848
}
849

    
850
void av_log_set_level(int level)
851
{
852
    av_log_level = level;
853
}
854

    
855
void av_log_set_callback(void (*callback)(AVCodecContext*, int, const char*, va_list))
856
{
857
    av_log_callback = callback;
858
}
859