utils.c 36.2 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * utils for libavcodec
3
 * Copyright (c) 2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
Fabrice Bellard's avatar
Fabrice Bellard committed
5
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
21
 */
22

Michael Niedermayer's avatar
Michael Niedermayer committed
23
/**
24
 * @file libavcodec/utils.c
Michael Niedermayer's avatar
Michael Niedermayer committed
25 26
 * utils.
 */
27

28
/* needed for mkstemp() */
29
#define _XOPEN_SOURCE 600
30

31
#include "libavutil/avstring.h"
32 33
#include "libavutil/integer.h"
#include "libavutil/crc.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
34
#include "avcodec.h"
35
#include "dsputil.h"
36
#include "opt.h"
37
#include "imgconvert.h"
38
#include "audioconvert.h"
39
#include "internal.h"
40
#include <stdlib.h>
41
#include <stdarg.h>
42
#include <limits.h>
Michael Niedermayer's avatar
Michael Niedermayer committed
43
#include <float.h>
44
#if !HAVE_MKSTEMP
45 46
#include <fcntl.h>
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
47

48
static int volatile entangled_thread_counter=0;
49 50
int (*ff_lockmgr_cb)(void **mutex, enum AVLockOp op);
static void *codec_mutex;
51

52
void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
53
{
54
    if(min_size < *size)
55
        return ptr;
56

57
    *size= FFMAX(17*min_size/16 + 32, min_size);
58

59 60 61 62 63
    ptr= av_realloc(ptr, *size);
    if(!ptr) //we could set this to the unmodified min_size but this is safer if the user lost the ptr and uses NULL now
        *size= 0;

    return ptr;
64 65
}

66 67 68 69 70 71 72 73 74 75 76
void av_fast_malloc(void *ptr, unsigned int *size, unsigned int min_size)
{
    void **p = ptr;
    if (min_size < *size)
        return;
    *size= FFMAX(17*min_size/16 + 32, min_size);
    av_free(*p);
    *p = av_malloc(*size);
    if (!*p) *size = 0;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
77
/* encoder management */
78
static AVCodec *first_avcodec = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
79

80 81 82 83 84
AVCodec *av_codec_next(AVCodec *c){
    if(c) return c->next;
    else  return first_avcodec;
}

85
void avcodec_register(AVCodec *codec)
Fabrice Bellard's avatar
Fabrice Bellard committed
86 87
{
    AVCodec **p;
88
    avcodec_init();
Fabrice Bellard's avatar
Fabrice Bellard committed
89 90
    p = &first_avcodec;
    while (*p != NULL) p = &(*p)->next;
91 92
    *p = codec;
    codec->next = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
93 94
}

95
#if LIBAVCODEC_VERSION_MAJOR < 53
96 97 98 99
void register_avcodec(AVCodec *codec)
{
    avcodec_register(codec);
}
100
#endif
101

102 103 104 105 106 107 108
void avcodec_set_dimensions(AVCodecContext *s, int width, int height){
    s->coded_width = width;
    s->coded_height= height;
    s->width = -((-width )>>s->lowres);
    s->height= -((-height)>>s->lowres);
}

109
typedef struct InternalBuffer{
Michael Niedermayer's avatar
Michael Niedermayer committed
110
    int last_pic_num;
111
    uint8_t *base[4];
Michael Niedermayer's avatar
Michael Niedermayer committed
112
    uint8_t *data[4];
113
    int linesize[4];
114 115
    int width, height;
    enum PixelFormat pix_fmt;
116 117 118
}InternalBuffer;

#define INTERNAL_BUFFER_SIZE 32
Michael Niedermayer's avatar
Michael Niedermayer committed
119

120
void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
121 122 123
    int w_align= 1;
    int h_align= 1;

124 125
    switch(s->pix_fmt){
    case PIX_FMT_YUV420P:
126
    case PIX_FMT_YUYV422:
127
    case PIX_FMT_UYVY422:
128
    case PIX_FMT_YUV422P:
129
    case PIX_FMT_YUV440P:
130 131
    case PIX_FMT_YUV444P:
    case PIX_FMT_GRAY8:
132 133
    case PIX_FMT_GRAY16BE:
    case PIX_FMT_GRAY16LE:
134 135
    case PIX_FMT_YUVJ420P:
    case PIX_FMT_YUVJ422P:
136
    case PIX_FMT_YUVJ440P:
137
    case PIX_FMT_YUVJ444P:
138
    case PIX_FMT_YUVA420P:
139 140
        w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
        h_align= 16;
141
        if(s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id == CODEC_ID_AMV || s->codec_id == CODEC_ID_THP)
142
            h_align= 32; // interlaced is rounded up to 2 MBs
143 144
        break;
    case PIX_FMT_YUV411P:
145
    case PIX_FMT_UYYVYY411:
146 147 148 149 150 151 152 153
        w_align=32;
        h_align=8;
        break;
    case PIX_FMT_YUV410P:
        if(s->codec_id == CODEC_ID_SVQ1){
            w_align=64;
            h_align=64;
        }
154 155 156 157 158 159
    case PIX_FMT_RGB555:
        if(s->codec_id == CODEC_ID_RPZA){
            w_align=4;
            h_align=4;
        }
    case PIX_FMT_PAL8:
160 161
    case PIX_FMT_BGR8:
    case PIX_FMT_RGB8:
162 163 164 165
        if(s->codec_id == CODEC_ID_SMC){
            w_align=4;
            h_align=4;
        }
166
        break;
167 168 169 170 171 172
    case PIX_FMT_BGR24:
        if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){
            w_align=4;
            h_align=4;
        }
        break;
173 174 175 176 177 178
    default:
        w_align= 1;
        h_align= 1;
        break;
    }

179 180
    *width = FFALIGN(*width , w_align);
    *height= FFALIGN(*height, h_align);
181 182
    if(s->codec_id == CODEC_ID_H264)
        *height+=2; // some of the optimized chroma MC reads one line too much
183 184
}

185
int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){
186
    if((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/8)
187
        return 0;
188

189 190 191 192
    av_log(av_log_ctx, AV_LOG_ERROR, "picture size invalid (%ux%u)\n", w, h);
    return -1;
}

193
int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
Michael Niedermayer's avatar
Michael Niedermayer committed
194
    int i;
195 196
    int w= s->width;
    int h= s->height;
197
    InternalBuffer *buf;
198
    int *picture_number;
199

200 201 202 203 204 205 206 207
    if(pic->data[0]!=NULL) {
        av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
        return -1;
    }
    if(s->internal_buffer_count >= INTERNAL_BUFFER_SIZE) {
        av_log(s, AV_LOG_ERROR, "internal_buffer_count overflow (missing release_buffer?)\n");
        return -1;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
208

209 210 211
    if(avcodec_check_dimensions(s,w,h))
        return -1;

212
    if(s->internal_buffer==NULL){
213
        s->internal_buffer= av_mallocz((INTERNAL_BUFFER_SIZE+1)*sizeof(InternalBuffer));
214 215 216
    }
#if 0
    s->internal_buffer= av_fast_realloc(
217 218
        s->internal_buffer,
        &s->internal_buffer_size,
219 220 221
        sizeof(InternalBuffer)*FFMAX(99,  s->internal_buffer_count+1)/*FIXME*/
        );
#endif
222

223
    buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
224
    picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE]).last_pic_num; //FIXME ugly hack
225
    (*picture_number)++;
226

227 228 229 230 231 232 233
    if(buf->base[0] && (buf->width != w || buf->height != h || buf->pix_fmt != s->pix_fmt)){
        for(i=0; i<4; i++){
            av_freep(&buf->base[i]);
            buf->data[i]= NULL;
        }
    }

234
    if(buf->base[0]){
235 236
        pic->age= *picture_number - buf->last_pic_num;
        buf->last_pic_num= *picture_number;
Michael Niedermayer's avatar
Michael Niedermayer committed
237
    }else{
238
        int h_chroma_shift, v_chroma_shift;
239 240
        int size[4] = {0};
        int tmpsize;
241
        int unaligned;
242
        AVPicture picture;
243
        int stride_align[4];
244

Michael Niedermayer's avatar
Michael Niedermayer committed
245
        avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
246 247

        avcodec_align_dimensions(s, &w, &h);
248

Michael Niedermayer's avatar
Michael Niedermayer committed
249 250 251 252
        if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
            w+= EDGE_WIDTH*2;
            h+= EDGE_WIDTH*2;
        }
253

254 255 256
        do {
            // NOTE: do not align linesizes individually, this breaks e.g. assumptions
            // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
257
            ff_fill_linesize(&picture, s->pix_fmt, w);
258 259
            // increase alignment of w for next try (rhs gives the lowest bit set in w)
            w += w & ~(w-1);
260

261
            unaligned = 0;
262
            for (i=0; i<4; i++){
263 264 265 266
//STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
//we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
//picture size unneccessarily in some cases. The solution here is not
//pretty and better ideas are welcome!
267
#if HAVE_MMX
268 269 270
                if(s->codec_id == CODEC_ID_SVQ1)
                    stride_align[i]= 16;
                else
271
#endif
272
                stride_align[i] = STRIDE_ALIGN;
273
                unaligned |= picture.linesize[i] % stride_align[i];
274
            }
275
        } while (unaligned);
276 277

        tmpsize = ff_fill_pointer(&picture, NULL, s->pix_fmt, h);
278 279
        if (tmpsize < 0)
            return -1;
280 281 282

        for (i=0; i<3 && picture.data[i+1]; i++)
            size[i] = picture.data[i+1] - picture.data[i];
283
        size[i] = tmpsize - (picture.data[i] - picture.data[0]);
284

285
        buf->last_pic_num= -256*256*256*64;
286 287
        memset(buf->base, 0, sizeof(buf->base));
        memset(buf->data, 0, sizeof(buf->data));
Michael Niedermayer's avatar
Michael Niedermayer committed
288

289
        for(i=0; i<4 && size[i]; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
290 291
            const int h_shift= i==0 ? 0 : h_chroma_shift;
            const int v_shift= i==0 ? 0 : v_chroma_shift;
Michael Niedermayer's avatar
Michael Niedermayer committed
292

293
            buf->linesize[i]= picture.linesize[i];
Michael Niedermayer's avatar
Michael Niedermayer committed
294

295
            buf->base[i]= av_malloc(size[i]+16); //FIXME 16
296
            if(buf->base[i]==NULL) return -1;
297 298
            memset(buf->base[i], 128, size[i]);

299 300
            // no edge if EDEG EMU or not planar YUV
            if((s->flags&CODEC_FLAG_EMU_EDGE) || !size[2])
301
                buf->data[i] = buf->base[i];
Michael Niedermayer's avatar
Michael Niedermayer committed
302
            else
303
                buf->data[i] = buf->base[i] + FFALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), stride_align[i]);
Michael Niedermayer's avatar
Michael Niedermayer committed
304
        }
305 306
        if(size[1] && !size[2])
            ff_set_systematic_pal((uint32_t*)buf->data[1], s->pix_fmt);
307 308 309
        buf->width  = s->width;
        buf->height = s->height;
        buf->pix_fmt= s->pix_fmt;
Michael Niedermayer's avatar
Michael Niedermayer committed
310 311
        pic->age= 256*256*256*64;
    }
312
    pic->type= FF_BUFFER_TYPE_INTERNAL;
Michael Niedermayer's avatar
Michael Niedermayer committed
313

314 315 316
    for(i=0; i<4; i++){
        pic->base[i]= buf->base[i];
        pic->data[i]= buf->data[i];
317
        pic->linesize[i]= buf->linesize[i];
318 319 320
    }
    s->internal_buffer_count++;

321 322
    pic->reordered_opaque= s->reordered_opaque;

323 324 325
    if(s->debug&FF_DEBUG_BUFFERS)
        av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);

Michael Niedermayer's avatar
Michael Niedermayer committed
326 327 328
    return 0;
}

329
void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
Michael Niedermayer's avatar
Michael Niedermayer committed
330
    int i;
331
    InternalBuffer *buf, *last;
332

Michael Niedermayer's avatar
Michael Niedermayer committed
333
    assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
Michael Niedermayer's avatar
Michael Niedermayer committed
334
    assert(s->internal_buffer_count);
335

Fabrice Bellard's avatar
Fabrice Bellard committed
336
    buf = NULL; /* avoids warning */
337 338 339 340 341 342 343 344 345
    for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
        buf= &((InternalBuffer*)s->internal_buffer)[i];
        if(buf->data[0] == pic->data[0])
            break;
    }
    assert(i < s->internal_buffer_count);
    s->internal_buffer_count--;
    last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];

346
    FFSWAP(InternalBuffer, *buf, *last);
347

348
    for(i=0; i<4; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
349
        pic->data[i]=NULL;
350 351
//        pic->base[i]=NULL;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
352
//printf("R%X\n", pic->opaque);
353 354 355

    if(s->debug&FF_DEBUG_BUFFERS)
        av_log(s, AV_LOG_DEBUG, "default_release_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
Michael Niedermayer's avatar
Michael Niedermayer committed
356 357
}

358 359 360 361 362 363 364 365 366 367 368 369
int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
    AVFrame temp_pic;
    int i;

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

    /* If internal buffer type return the same buffer */
370 371
    if(pic->type == FF_BUFFER_TYPE_INTERNAL) {
        pic->reordered_opaque= s->reordered_opaque;
372
        return 0;
373
    }
374 375 376 377 378 379 380 381 382 383 384 385

    /*
     * Not internal type and reget_buffer not overridden, emulate cr buffer
     */
    temp_pic = *pic;
    for(i = 0; i < 4; i++)
        pic->data[i] = pic->base[i] = NULL;
    pic->opaque = NULL;
    /* Allocate new frame */
    if (s->get_buffer(s, pic))
        return -1;
    /* Copy image data from old buffer to new buffer */
386
    av_picture_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
387 388 389 390 391
             s->height);
    s->release_buffer(s, &temp_pic); // Release old frame
    return 0;
}

392
int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size){
393 394 395
    int i;

    for(i=0; i<count; i++){
396
        int r= func(c, (char*)arg + i*size);
397 398 399 400 401
        if(ret) ret[i]= r;
    }
    return 0;
}

402 403 404 405 406 407 408 409 410 411
int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr),void *arg, int *ret, int count){
    int i;

    for(i=0; i<count; i++){
        int r= func(c, arg, i, 0);
        if(ret) ret[i]= r;
    }
    return 0;
}

412 413 414
enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt){
    while (*fmt != PIX_FMT_NONE && ff_is_hwaccel_pix_fmt(*fmt))
        ++fmt;
Michael Niedermayer's avatar
Michael Niedermayer committed
415 416 417
    return fmt[0];
}

418 419 420 421
void avcodec_get_frame_defaults(AVFrame *pic){
    memset(pic, 0, sizeof(AVFrame));

    pic->pts= AV_NOPTS_VALUE;
422
    pic->key_frame= 1;
423 424
}

425
AVFrame *avcodec_alloc_frame(void){
426
    AVFrame *pic= av_malloc(sizeof(AVFrame));
427

428
    if(pic==NULL) return NULL;
429

430
    avcodec_get_frame_defaults(pic);
431

Michael Niedermayer's avatar
Michael Niedermayer committed
432 433 434
    return pic;
}

435
int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
Fabrice Bellard's avatar
Fabrice Bellard committed
436
{
437
    int ret= -1;
438

439 440 441 442 443 444
    /* If there is a user-supplied mutex locking routine, call it. */
    if (ff_lockmgr_cb) {
        if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
            return -1;
    }

445 446 447 448 449
    entangled_thread_counter++;
    if(entangled_thread_counter != 1){
        av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
        goto end;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
450

451
    if(avctx->codec || !codec)
452
        goto end;
453

454 455
    if (codec->priv_data_size > 0) {
        avctx->priv_data = av_mallocz(codec->priv_data_size);
456 457
        if (!avctx->priv_data) {
            ret = AVERROR(ENOMEM);
458
            goto end;
459
        }
460 461 462
    } else {
        avctx->priv_data = NULL;
    }
463 464 465 466 467 468

    if(avctx->coded_width && avctx->coded_height)
        avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
    else if(avctx->width && avctx->height)
        avcodec_set_dimensions(avctx, avctx->width, avctx->height);

469
#define SANE_NB_CHANNELS 128U
470 471 472
    if (((avctx->coded_width || avctx->coded_height)
        && avcodec_check_dimensions(avctx, avctx->coded_width, avctx->coded_height))
        || avctx->channels > SANE_NB_CHANNELS) {
473
        ret = AVERROR(EINVAL);
474
        goto free_and_end;
475 476
    }

477
    avctx->codec = codec;
478 479 480 481 482
    if ((avctx->codec_type == CODEC_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
        avctx->codec_id == CODEC_ID_NONE) {
        avctx->codec_type = codec->type;
        avctx->codec_id   = codec->id;
    }
483 484
    if(avctx->codec_id != codec->id || avctx->codec_type != codec->type){
        av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
485
        goto free_and_end;
486
    }
487
    avctx->frame_number = 0;
488
    if(avctx->codec->init){
Michael Niedermayer's avatar
Michael Niedermayer committed
489 490
        ret = avctx->codec->init(avctx);
        if (ret < 0) {
491
            goto free_and_end;
Michael Niedermayer's avatar
Michael Niedermayer committed
492
        }
493
    }
494 495 496
    ret=0;
end:
    entangled_thread_counter--;
497 498 499 500 501

    /* Release any user-supplied mutex. */
    if (ff_lockmgr_cb) {
        (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
    }
502
    return ret;
503 504 505 506
free_and_end:
    av_freep(&avctx->priv_data);
    avctx->codec= NULL;
    goto end;
Fabrice Bellard's avatar
Fabrice Bellard committed
507 508
}

509
int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
Fabrice Bellard's avatar
Fabrice Bellard committed
510 511
                         const short *samples)
{
512
    if(buf_size < FF_MIN_BUFFER_SIZE && 0){
Michel Bardiaux's avatar
Michel Bardiaux committed
513
        av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
514 515
        return -1;
    }
516
    if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){
517
        int ret = avctx->codec->encode(avctx, buf, buf_size, samples);
518 519 520 521
        avctx->frame_number++;
        return ret;
    }else
        return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
522 523
}

524
int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
525
                         const AVFrame *pict)
Fabrice Bellard's avatar
Fabrice Bellard committed
526
{
527
    if(buf_size < FF_MIN_BUFFER_SIZE){
Michel Bardiaux's avatar
Michel Bardiaux committed
528
        av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
529 530 531 532
        return -1;
    }
    if(avcodec_check_dimensions(avctx,avctx->width,avctx->height))
        return -1;
533
    if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){
534
        int ret = avctx->codec->encode(avctx, buf, buf_size, pict);
535
        avctx->frame_number++;
Diego Biurrun's avatar
Diego Biurrun committed
536
        emms_c(); //needed to avoid an emms_c() call before every return;
537

538 539 540
        return ret;
    }else
        return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
541 542
}

543
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
544 545 546
                            const AVSubtitle *sub)
{
    int ret;
547 548 549 550
    if(sub->start_display_time) {
        av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
        return -1;
    }
551 552
    if(sub->num_rects == 0 || !sub->rects)
        return -1;
553
    ret = avctx->codec->encode(avctx, buf, buf_size, sub);
554 555 556 557
    avctx->frame_number++;
    return ret;
}

558
#if LIBAVCODEC_VERSION_MAJOR < 53
559
int attribute_align_arg avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
Fabrice Bellard's avatar
Fabrice Bellard committed
560
                         int *got_picture_ptr,
561
                         const uint8_t *buf, int buf_size)
562 563 564 565 566
{
    AVPacket avpkt;
    av_init_packet(&avpkt);
    avpkt.data = buf;
    avpkt.size = buf_size;
567 568
    // HACK for CorePNG to decode as normal PNG by default
    avpkt.flags = AV_PKT_FLAG_KEY;
569 570 571 572 573 574 575 576

    return avcodec_decode_video2(avctx, picture, got_picture_ptr, &avpkt);
}
#endif

int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                         int *got_picture_ptr,
                         AVPacket *avpkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
577 578
{
    int ret;
579

580
    *got_picture_ptr= 0;
581 582
    if((avctx->coded_width||avctx->coded_height) && avcodec_check_dimensions(avctx,avctx->coded_width,avctx->coded_height))
        return -1;
583
    if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size){
584
        ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
585
                                avpkt);
586

Diego Biurrun's avatar
Diego Biurrun committed
587
        emms_c(); //needed to avoid an emms_c() call before every return;
588 589

        if (*got_picture_ptr)
590 591 592 593
            avctx->frame_number++;
    }else
        ret= 0;

Fabrice Bellard's avatar
Fabrice Bellard committed
594 595 596
    return ret;
}

597
#if LIBAVCODEC_VERSION_MAJOR < 53
598
int attribute_align_arg avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
Fabrice Bellard's avatar
Fabrice Bellard committed
599
                         int *frame_size_ptr,
600
                         const uint8_t *buf, int buf_size)
601 602 603 604 605 606 607 608 609 610 611 612 613
{
    AVPacket avpkt;
    av_init_packet(&avpkt);
    avpkt.data = buf;
    avpkt.size = buf_size;

    return avcodec_decode_audio3(avctx, samples, frame_size_ptr, &avpkt);
}
#endif

int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
                         int *frame_size_ptr,
                         AVPacket *avpkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
614 615 616
{
    int ret;

617
    if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size){
618 619 620 621 622 623
        //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
        if(*frame_size_ptr < AVCODEC_MAX_AUDIO_FRAME_SIZE){
            av_log(avctx, AV_LOG_ERROR, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
            return -1;
        }
        if(*frame_size_ptr < FF_MIN_BUFFER_SIZE ||
624
        *frame_size_ptr < avctx->channels * avctx->frame_size * sizeof(int16_t)){
625 626 627 628
            av_log(avctx, AV_LOG_ERROR, "buffer %d too small\n", *frame_size_ptr);
            return -1;
        }

629
        ret = avctx->codec->decode(avctx, samples, frame_size_ptr, avpkt);
630
        avctx->frame_number++;
631
    }else{
632
        ret= 0;
633 634
        *frame_size_ptr=0;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
635 636 637
    return ret;
}

638
#if LIBAVCODEC_VERSION_MAJOR < 53
639 640 641
int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
                            int *got_sub_ptr,
                            const uint8_t *buf, int buf_size)
642 643 644 645 646 647 648 649 650 651 652 653 654
{
    AVPacket avpkt;
    av_init_packet(&avpkt);
    avpkt.data = buf;
    avpkt.size = buf_size;

    return avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, &avpkt);
}
#endif

int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
                            int *got_sub_ptr,
                            AVPacket *avpkt)
655 656 657 658
{
    int ret;

    *got_sub_ptr = 0;
659
    ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
660 661 662 663 664
    if (*got_sub_ptr)
        avctx->frame_number++;
    return ret;
}

665
av_cold int avcodec_close(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
666
{
667 668 669 670 671 672
    /* If there is a user-supplied mutex locking routine, call it. */
    if (ff_lockmgr_cb) {
        if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
            return -1;
    }

673 674 675 676 677 678 679
    entangled_thread_counter++;
    if(entangled_thread_counter != 1){
        av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
        entangled_thread_counter--;
        return -1;
    }

680
    if (HAVE_THREADS && avctx->thread_opaque)
Janne Grunau's avatar
Janne Grunau committed
681
        avcodec_thread_free(avctx);
682
    if (avctx->codec && avctx->codec->close)
Fabrice Bellard's avatar
Fabrice Bellard committed
683
        avctx->codec->close(avctx);
684
    avcodec_default_free_buffers(avctx);
685
    av_freep(&avctx->priv_data);
Fabrice Bellard's avatar
Fabrice Bellard committed
686
    avctx->codec = NULL;
687
    entangled_thread_counter--;
688 689 690 691 692

    /* Release any user-supplied mutex. */
    if (ff_lockmgr_cb) {
        (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
    return 0;
}

AVCodec *avcodec_find_encoder(enum CodecID id)
{
    AVCodec *p;
    p = first_avcodec;
    while (p) {
        if (p->encode != NULL && p->id == id)
            return p;
        p = p->next;
    }
    return NULL;
}

708 709 710
AVCodec *avcodec_find_encoder_by_name(const char *name)
{
    AVCodec *p;
711 712
    if (!name)
        return NULL;
713 714 715 716 717 718 719 720 721
    p = first_avcodec;
    while (p) {
        if (p->encode != NULL && strcmp(name,p->name) == 0)
            return p;
        p = p->next;
    }
    return NULL;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
AVCodec *avcodec_find_decoder(enum CodecID id)
{
    AVCodec *p;
    p = first_avcodec;
    while (p) {
        if (p->decode != NULL && p->id == id)
            return p;
        p = p->next;
    }
    return NULL;
}

AVCodec *avcodec_find_decoder_by_name(const char *name)
{
    AVCodec *p;
737 738
    if (!name)
        return NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
739 740 741 742 743 744 745 746 747
    p = first_avcodec;
    while (p) {
        if (p->decode != NULL && strcmp(name,p->name) == 0)
            return p;
        p = p->next;
    }
    return NULL;
}

748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
int av_get_bit_rate(AVCodecContext *ctx)
{
    int bit_rate;
    int bits_per_sample;

    switch(ctx->codec_type) {
    case CODEC_TYPE_VIDEO:
        bit_rate = ctx->bit_rate;
        break;
    case CODEC_TYPE_AUDIO:
        bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
        bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
        break;
    case CODEC_TYPE_DATA:
        bit_rate = ctx->bit_rate;
        break;
    case CODEC_TYPE_SUBTITLE:
        bit_rate = ctx->bit_rate;
        break;
    case CODEC_TYPE_ATTACHMENT:
        bit_rate = ctx->bit_rate;
        break;
    default:
        bit_rate = 0;
        break;
    }
    return bit_rate;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
777 778 779 780 781
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
{
    const char *codec_name;
    AVCodec *p;
    char buf1[32];
Fabrice Bellard's avatar
Fabrice Bellard committed
782
    int bitrate;
783
    AVRational display_aspect_ratio;
Fabrice Bellard's avatar
Fabrice Bellard committed
784 785 786 787 788 789 790 791

    if (encode)
        p = avcodec_find_encoder(enc->codec_id);
    else
        p = avcodec_find_decoder(enc->codec_id);

    if (p) {
        codec_name = p->name;
792 793 794 795
    } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
        /* fake mpeg2 transport stream codec (currently not
           registered) */
        codec_name = "mpeg2ts";
Fabrice Bellard's avatar
Fabrice Bellard committed
796 797 798 799
    } else if (enc->codec_name[0] != '\0') {
        codec_name = enc->codec_name;
    } else {
        /* output avi tags */
800
        if(   isprint(enc->codec_tag&0xFF) && isprint((enc->codec_tag>>8)&0xFF)
801
           && isprint((enc->codec_tag>>16)&0xFF) && isprint((enc->codec_tag>>24)&0xFF)){
802
            snprintf(buf1, sizeof(buf1), "%c%c%c%c / 0x%04X",
Fabrice Bellard's avatar
Fabrice Bellard committed
803 804 805
                     enc->codec_tag & 0xff,
                     (enc->codec_tag >> 8) & 0xff,
                     (enc->codec_tag >> 16) & 0xff,
806 807
                     (enc->codec_tag >> 24) & 0xff,
                      enc->codec_tag);
Fabrice Bellard's avatar
Fabrice Bellard committed
808 809 810 811 812 813 814 815 816 817
        } else {
            snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
        }
        codec_name = buf1;
    }

    switch(enc->codec_type) {
    case CODEC_TYPE_VIDEO:
        snprintf(buf, buf_size,
                 "Video: %s%s",
818
                 codec_name, enc->mb_decision ? " (hq)" : "");
819
        if (enc->pix_fmt != PIX_FMT_NONE) {
Fabrice Bellard's avatar
Fabrice Bellard committed
820 821
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", %s",
822
                     avcodec_get_pix_fmt_name(enc->pix_fmt));
Fabrice Bellard's avatar
Fabrice Bellard committed
823
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
824 825
        if (enc->width) {
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
826 827
                     ", %dx%d",
                     enc->width, enc->height);
828
            if (enc->sample_aspect_ratio.num) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
829 830 831 832 833 834 835 836
                av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
                          enc->width*enc->sample_aspect_ratio.num,
                          enc->height*enc->sample_aspect_ratio.den,
                          1024*1024);
                snprintf(buf + strlen(buf), buf_size - strlen(buf),
                         " [PAR %d:%d DAR %d:%d]",
                         enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
                         display_aspect_ratio.num, display_aspect_ratio.den);
837
            }
838
            if(av_log_get_level() >= AV_LOG_DEBUG){
839
                int g= av_gcd(enc->time_base.num, enc->time_base.den);
840 841 842 843
                snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", %d/%d",
                     enc->time_base.num/g, enc->time_base.den/g);
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
844
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
845 846 847 848
        if (encode) {
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", q=%d-%d", enc->qmin, enc->qmax);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
849 850 851 852 853 854 855
        break;
    case CODEC_TYPE_AUDIO:
        snprintf(buf, buf_size,
                 "Audio: %s",
                 codec_name);
        if (enc->sample_rate) {
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
856
                     ", %d Hz", enc->sample_rate);
Fabrice Bellard's avatar
Fabrice Bellard committed
857
        }
858 859
        av_strlcat(buf, ", ", buf_size);
        avcodec_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
860 861 862 863
        if (enc->sample_fmt != SAMPLE_FMT_NONE) {
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", %s", avcodec_get_sample_fmt_name(enc->sample_fmt));
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
864
        break;
865 866
    case CODEC_TYPE_DATA:
        snprintf(buf, buf_size, "Data: %s", codec_name);
867 868 869
        break;
    case CODEC_TYPE_SUBTITLE:
        snprintf(buf, buf_size, "Subtitle: %s", codec_name);
870
        break;
871 872 873
    case CODEC_TYPE_ATTACHMENT:
        snprintf(buf, buf_size, "Attachment: %s", codec_name);
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
874
    default:
875 876
        snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
        return;
Fabrice Bellard's avatar
Fabrice Bellard committed
877
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
878 879 880 881 882 883 884 885
    if (encode) {
        if (enc->flags & CODEC_FLAG_PASS1)
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", pass 1");
        if (enc->flags & CODEC_FLAG_PASS2)
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", pass 2");
    }
886
    bitrate = av_get_bit_rate(enc);
Fabrice Bellard's avatar
Fabrice Bellard committed
887
    if (bitrate != 0) {
888
        snprintf(buf + strlen(buf), buf_size - strlen(buf),
Fabrice Bellard's avatar
Fabrice Bellard committed
889
                 ", %d kb/s", bitrate / 1000);
Fabrice Bellard's avatar
Fabrice Bellard committed
890 891 892
    }
}

Nick Kurshev's avatar
Nick Kurshev committed
893 894 895 896
unsigned avcodec_version( void )
{
  return LIBAVCODEC_VERSION_INT;
}
Fabrice Bellard's avatar
Fabrice Bellard committed
897

898
const char *avcodec_configuration(void)
899 900 901 902
{
    return FFMPEG_CONFIGURATION;
}

903
const char *avcodec_license(void)
904 905 906 907 908
{
#define LICENSE_PREFIX "libavcodec license: "
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
909 910
void avcodec_init(void)
{
911
    static int initialized = 0;
912

913
    if (initialized != 0)
914
        return;
915
    initialized = 1;
916

Måns Rullgård's avatar
Måns Rullgård committed
917
    dsputil_static_init();
Fabrice Bellard's avatar
Fabrice Bellard committed
918 919
}

920 921
void avcodec_flush_buffers(AVCodecContext *avctx)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
922 923
    if(avctx->codec->flush)
        avctx->codec->flush(avctx);
924 925
}

926
void avcodec_default_free_buffers(AVCodecContext *s){
927 928 929
    int i, j;

    if(s->internal_buffer==NULL) return;
930

931 932
    if (s->internal_buffer_count)
        av_log(s, AV_LOG_WARNING, "Found %i unreleased buffers!\n", s->internal_buffer_count);
933 934 935 936 937 938 939 940
    for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
        InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
        for(j=0; j<4; j++){
            av_freep(&buf->base[j]);
            buf->data[j]= NULL;
        }
    }
    av_freep(&s->internal_buffer);
941

942 943 944
    s->internal_buffer_count=0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
945 946
char av_get_pict_type_char(int pict_type){
    switch(pict_type){
947 948 949 950 951 952
    case FF_I_TYPE: return 'I';
    case FF_P_TYPE: return 'P';
    case FF_B_TYPE: return 'B';
    case FF_S_TYPE: return 'S';
    case FF_SI_TYPE:return 'i';
    case FF_SP_TYPE:return 'p';
953
    case FF_BI_TYPE:return 'b';
Aurelien Jacobs's avatar
Aurelien Jacobs committed
954
    default:        return '?';
Michael Niedermayer's avatar
Michael Niedermayer committed
955 956 957
    }
}

958 959
int av_get_bits_per_sample(enum CodecID codec_id){
    switch(codec_id){
960
    case CODEC_ID_ADPCM_SBPRO_2:
961
        return 2;
962
    case CODEC_ID_ADPCM_SBPRO_3:
963
        return 3;
964
    case CODEC_ID_ADPCM_SBPRO_4:
965
    case CODEC_ID_ADPCM_CT:
966
    case CODEC_ID_ADPCM_IMA_WAV:
967 968
    case CODEC_ID_ADPCM_MS:
    case CODEC_ID_ADPCM_YAMAHA:
969
        return 4;
970 971 972 973
    case CODEC_ID_PCM_ALAW:
    case CODEC_ID_PCM_MULAW:
    case CODEC_ID_PCM_S8:
    case CODEC_ID_PCM_U8:
974
    case CODEC_ID_PCM_ZORK:
975 976 977
        return 8;
    case CODEC_ID_PCM_S16BE:
    case CODEC_ID_PCM_S16LE:
978
    case CODEC_ID_PCM_S16LE_PLANAR:
979 980 981 982 983 984 985 986 987 988 989 990 991
    case CODEC_ID_PCM_U16BE:
    case CODEC_ID_PCM_U16LE:
        return 16;
    case CODEC_ID_PCM_S24DAUD:
    case CODEC_ID_PCM_S24BE:
    case CODEC_ID_PCM_S24LE:
    case CODEC_ID_PCM_U24BE:
    case CODEC_ID_PCM_U24LE:
        return 24;
    case CODEC_ID_PCM_S32BE:
    case CODEC_ID_PCM_S32LE:
    case CODEC_ID_PCM_U32BE:
    case CODEC_ID_PCM_U32LE:
992
    case CODEC_ID_PCM_F32BE:
993
    case CODEC_ID_PCM_F32LE:
994
        return 32;
995 996 997
    case CODEC_ID_PCM_F64BE:
    case CODEC_ID_PCM_F64LE:
        return 64;
998 999 1000 1001 1002
    default:
        return 0;
    }
}

1003 1004 1005 1006 1007 1008 1009 1010 1011
int av_get_bits_per_sample_format(enum SampleFormat sample_fmt) {
    switch (sample_fmt) {
    case SAMPLE_FMT_U8:
        return 8;
    case SAMPLE_FMT_S16:
        return 16;
    case SAMPLE_FMT_S32:
    case SAMPLE_FMT_FLT:
        return 32;
Peter Ross's avatar
Peter Ross committed
1012 1013
    case SAMPLE_FMT_DBL:
        return 64;
1014 1015 1016 1017 1018
    default:
        return 0;
    }
}

1019
#if !HAVE_THREADS
1020
int avcodec_thread_init(AVCodecContext *s, int thread_count){
1021
    s->thread_count = thread_count;
1022 1023 1024
    return -1;
}
#endif
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038

unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
{
    unsigned int n = 0;

    while(v >= 0xff) {
        *s++ = 0xff;
        v -= 0xff;
        n++;
    }
    *s = v;
    n++;
    return n;
}
1039 1040 1041 1042 1043 1044 1045 1046

/* Wrapper to work around the lack of mkstemp() on mingw/cygin.
 * Also, tries to create file in /tmp first, if possible.
 * *prefix can be a character constant; *filename will be allocated internally.
 * Returns file descriptor of opened file (or -1 on error)
 * and opened file name in **filename. */
int av_tempfile(char *prefix, char **filename) {
    int fd=-1;
1047
#if !HAVE_MKSTEMP
1048 1049 1050
    *filename = tempnam(".", prefix);
#else
    size_t len = strlen(prefix) + 12; /* room for "/tmp/" and "XXXXXX\0" */
1051
    *filename = av_malloc(len);
1052 1053 1054 1055 1056 1057
#endif
    /* -----common section-----*/
    if (*filename == NULL) {
        av_log(NULL, AV_LOG_ERROR, "ff_tempfile: Cannot allocate file name\n");
        return -1;
    }
1058
#if !HAVE_MKSTEMP
1059
    fd = open(*filename, O_RDWR | O_BINARY | O_CREAT, 0444);
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
#else
    snprintf(*filename, len, "/tmp/%sXXXXXX", prefix);
    fd = mkstemp(*filename);
    if (fd < 0) {
        snprintf(*filename, len, "./%sXXXXXX", prefix);
        fd = mkstemp(*filename);
    }
#endif
    /* -----common section-----*/
    if (fd < 0) {
        av_log(NULL, AV_LOG_ERROR, "ff_tempfile: Cannot open temporary file %s\n", *filename);
        return -1;
    }
    return fd; /* success */
}
1075 1076

typedef struct {
1077
    const char *abbr;
1078
    int width, height;
1079 1080 1081 1082 1083 1084 1085
} VideoFrameSizeAbbr;

typedef struct {
    const char *abbr;
    int rate_num, rate_den;
} VideoFrameRateAbbr;

1086
static const VideoFrameSizeAbbr video_frame_size_abbrs[] = {
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
    { "ntsc",      720, 480 },
    { "pal",       720, 576 },
    { "qntsc",     352, 240 }, /* VCD compliant NTSC */
    { "qpal",      352, 288 }, /* VCD compliant PAL */
    { "sntsc",     640, 480 }, /* square pixel NTSC */
    { "spal",      768, 576 }, /* square pixel PAL */
    { "film",      352, 240 },
    { "ntsc-film", 352, 240 },
    { "sqcif",     128,  96 },
    { "qcif",      176, 144 },
    { "cif",       352, 288 },
    { "4cif",      704, 576 },
1099
    { "16cif",    1408,1152 },
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
    { "qqvga",     160, 120 },
    { "qvga",      320, 240 },
    { "vga",       640, 480 },
    { "svga",      800, 600 },
    { "xga",      1024, 768 },
    { "uxga",     1600,1200 },
    { "qxga",     2048,1536 },
    { "sxga",     1280,1024 },
    { "qsxga",    2560,2048 },
    { "hsxga",    5120,4096 },
    { "wvga",      852, 480 },
    { "wxga",     1366, 768 },
    { "wsxga",    1600,1024 },
    { "wuxga",    1920,1200 },
    { "woxga",    2560,1600 },
    { "wqsxga",   3200,2048 },
    { "wquxga",   3840,2400 },
    { "whsxga",   6400,4096 },
    { "whuxga",   7680,4800 },
    { "cga",       320, 200 },
    { "ega",       640, 350 },
    { "hd480",     852, 480 },
    { "hd720",    1280, 720 },
    { "hd1080",   1920,1080 },
};

1126
static const VideoFrameRateAbbr video_frame_rate_abbrs[]= {
1127 1128 1129 1130 1131 1132 1133 1134
    { "ntsc",      30000, 1001 },
    { "pal",          25,    1 },
    { "qntsc",     30000, 1001 }, /* VCD compliant NTSC */
    { "qpal",         25,    1 }, /* VCD compliant PAL */
    { "sntsc",     30000, 1001 }, /* square pixel NTSC */
    { "spal",         25,    1 }, /* square pixel PAL */
    { "film",         24,    1 },
    { "ntsc-film", 24000, 1001 },
1135 1136 1137 1138 1139
};

int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str)
{
    int i;
1140
    int n = FF_ARRAY_ELEMS(video_frame_size_abbrs);
1141
    char *p;
1142 1143 1144
    int frame_width = 0, frame_height = 0;

    for(i=0;i<n;i++) {
1145 1146 1147
        if (!strcmp(video_frame_size_abbrs[i].abbr, str)) {
            frame_width = video_frame_size_abbrs[i].width;
            frame_height = video_frame_size_abbrs[i].height;
1148 1149 1150 1151 1152
            break;
        }
    }
    if (i == n) {
        p = str;
1153
        frame_width = strtol(p, &p, 10);
1154 1155
        if (*p)
            p++;
1156
        frame_height = strtol(p, &p, 10);
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
    }
    if (frame_width <= 0 || frame_height <= 0)
        return -1;
    *width_ptr = frame_width;
    *height_ptr = frame_height;
    return 0;
}

int av_parse_video_frame_rate(AVRational *frame_rate, const char *arg)
{
    int i;
1168
    int n = FF_ARRAY_ELEMS(video_frame_rate_abbrs);
1169 1170 1171
    char* cp;

    /* First, we check our abbreviation table */
1172 1173 1174 1175
    for (i = 0; i < n; ++i)
         if (!strcmp(video_frame_rate_abbrs[i].abbr, arg)) {
             frame_rate->num = video_frame_rate_abbrs[i].rate_num;
             frame_rate->den = video_frame_rate_abbrs[i].rate_den;
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
             return 0;
         }

    /* Then, we try to parse it as fraction */
    cp = strchr(arg, '/');
    if (!cp)
        cp = strchr(arg, ':');
    if (cp) {
        char* cpp;
        frame_rate->num = strtol(arg, &cpp, 10);
        if (cpp != arg || cpp == cp)
            frame_rate->den = strtol(cp+1, &cpp, 10);
        else
           frame_rate->num = 0;
    }
    else {
        /* Finally we give up and parse it as double */
1193
        AVRational time_base = av_d2q(strtod(arg, 0), 1001000);
1194 1195 1196 1197 1198 1199 1200 1201
        frame_rate->den = time_base.den;
        frame_rate->num = time_base.num;
    }
    if (!frame_rate->num || !frame_rate->den)
        return -1;
    else
        return 0;
}
1202

1203 1204 1205 1206 1207 1208
int ff_match_2uint16(const uint16_t (*tab)[2], int size, int a, int b){
    int i;
    for(i=0; i<size && !(tab[i][0]==a && tab[i][1]==b); i++);
    return i;
}

1209
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
1210 1211 1212 1213 1214 1215
{
    av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your FFmpeg "
            "version to the newest one from SVN. If the problem still "
            "occurs, it means that your file has a feature which has not "
            "been implemented.", feature);
    if(want_sample)
1216
        av_log_ask_for_sample(avc, NULL);
1217 1218 1219 1220
    else
        av_log(avc, AV_LOG_WARNING, "\n");
}

1221
void av_log_ask_for_sample(void *avc, const char *msg)
1222 1223 1224 1225 1226 1227
{
    if (msg)
        av_log(avc, AV_LOG_WARNING, "%s ", msg);
    av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
            "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
            "and contact the ffmpeg-devel mailing list.\n");
1228
}
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239

static AVHWAccel *first_hwaccel = NULL;

void av_register_hwaccel(AVHWAccel *hwaccel)
{
    AVHWAccel **p = &first_hwaccel;
    while (*p)
        p = &(*p)->next;
    *p = hwaccel;
    hwaccel->next = NULL;
}
1240 1241 1242 1243 1244

AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
{
    return hwaccel ? hwaccel->next : first_hwaccel;
}
Michael Niedermayer's avatar
Michael Niedermayer committed
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256

AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt)
{
    AVHWAccel *hwaccel=NULL;

    while((hwaccel= av_hwaccel_next(hwaccel))){
        if (   hwaccel->id      == codec_id
            && hwaccel->pix_fmt == pix_fmt)
            return hwaccel;
    }
    return NULL;
}
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272

int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
{
    if (ff_lockmgr_cb) {
        if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY))
            return -1;
    }

    ff_lockmgr_cb = cb;

    if (ff_lockmgr_cb) {
        if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_CREATE))
            return -1;
    }
    return 0;
}