utils.c 70.3 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
 * This file is part of Libav.
7
 *
8
 * Libav 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
 * Libav 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 Libav; 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
Michael Niedermayer's avatar
Michael Niedermayer committed
25 26
 * utils.
 */
27

28
#include "config.h"
29
#include "libavutil/attributes.h"
30
#include "libavutil/avassert.h"
31
#include "libavutil/avstring.h"
32
#include "libavutil/channel_layout.h"
33
#include "libavutil/crc.h"
34
#include "libavutil/frame.h"
35
#include "libavutil/internal.h"
36
#include "libavutil/mathematics.h"
37
#include "libavutil/pixdesc.h"
38 39
#include "libavutil/imgutils.h"
#include "libavutil/samplefmt.h"
40
#include "libavutil/dict.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
41
#include "avcodec.h"
42
#include "dsputil.h"
43
#include "libavutil/opt.h"
44
#include "thread.h"
45
#include "internal.h"
46
#include "bytestream.h"
47
#include "version.h"
48
#include <stdlib.h>
49
#include <stdarg.h>
50
#include <limits.h>
Michael Niedermayer's avatar
Michael Niedermayer committed
51
#include <float.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
52

Luca Barbato's avatar
Luca Barbato committed
53
static int volatile entangled_thread_counter = 0;
54
static int (*lockmgr_cb)(void **mutex, enum AVLockOp op);
55
static void *codec_mutex;
56
static void *avformat_mutex;
57

58 59
#if FF_API_FAST_MALLOC && CONFIG_SHARED && HAVE_SYMVER
FF_SYMVER(void*, av_fast_realloc, (void *ptr, unsigned int *size, size_t min_size), "LIBAVCODEC_55")
60
{
61
    return av_fast_realloc(ptr, size, min_size);
62 63
}

64
FF_SYMVER(void, av_fast_malloc, (void *ptr, unsigned int *size, size_t min_size), "LIBAVCODEC_55")
65
{
66
    av_fast_malloc(ptr, size, min_size);
67
}
68
#endif
69

70 71 72 73 74 75 76 77 78 79 80 81 82
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
{
    void **p = ptr;
    if (min_size > SIZE_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
        av_freep(p);
        *size = 0;
        return;
    }
    av_fast_malloc(p, size, min_size + FF_INPUT_BUFFER_PADDING_SIZE);
    if (*size)
        memset((uint8_t *)*p + min_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
}

Fabrice Bellard's avatar
Fabrice Bellard committed
83
/* encoder management */
84
static AVCodec *first_avcodec = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
85

86 87
AVCodec *av_codec_next(const AVCodec *c)
{
Luca Barbato's avatar
Luca Barbato committed
88 89 90 91
    if (c)
        return c->next;
    else
        return first_avcodec;
92 93
}

94
static av_cold void avcodec_init(void)
95 96 97 98 99 100 101
{
    static int initialized = 0;

    if (initialized != 0)
        return;
    initialized = 1;

102 103
    if (CONFIG_DSPUTIL)
        ff_dsputil_static_init();
104 105
}

106
int av_codec_is_encoder(const AVCodec *codec)
107
{
108
    return codec && (codec->encode_sub || codec->encode2);
109 110
}

111
int av_codec_is_decoder(const AVCodec *codec)
112 113 114 115
{
    return codec && codec->decode;
}

116
av_cold void avcodec_register(AVCodec *codec)
Fabrice Bellard's avatar
Fabrice Bellard committed
117 118
{
    AVCodec **p;
119
    avcodec_init();
Fabrice Bellard's avatar
Fabrice Bellard committed
120
    p = &first_avcodec;
Luca Barbato's avatar
Luca Barbato committed
121 122 123
    while (*p != NULL)
        p = &(*p)->next;
    *p          = codec;
124
    codec->next = NULL;
125 126 127

    if (codec->init_static_data)
        codec->init_static_data(codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
128 129
}

130
#if FF_API_EMU_EDGE
131 132 133 134
unsigned avcodec_get_edge_width(void)
{
    return EDGE_WIDTH;
}
135
#endif
136

137
#if FF_API_SET_DIMENSIONS
Luca Barbato's avatar
Luca Barbato committed
138 139
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
{
140 141 142 143 144 145 146 147 148 149 150 151 152 153
    ff_set_dimensions(s, width, height);
}
#endif

int ff_set_dimensions(AVCodecContext *s, int width, int height)
{
    int ret = av_image_check_size(width, height, 0, s);

    if (ret < 0)
        width = height = 0;
    s->width  = s->coded_width  = width;
    s->height = s->coded_height = height;

    return ret;
154 155
}

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
int ff_side_data_update_matrix_encoding(AVFrame *frame,
                                        enum AVMatrixEncoding matrix_encoding)
{
    AVFrameSideData *side_data;
    enum AVMatrixEncoding *data;

    side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING);
    if (!side_data)
        side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING,
                                           sizeof(enum AVMatrixEncoding));

    if (!side_data)
        return AVERROR(ENOMEM);

    data  = (enum AVMatrixEncoding*)side_data->data;
    *data = matrix_encoding;

    return 0;
}

176
#if HAVE_NEON || ARCH_PPC || HAVE_MMX
177 178 179 180 181
#   define STRIDE_ALIGN 16
#else
#   define STRIDE_ALIGN 8
#endif

182 183 184 185
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
                               int linesize_align[AV_NUM_DATA_POINTERS])
{
    int i;
Luca Barbato's avatar
Luca Barbato committed
186 187
    int w_align = 1;
    int h_align = 1;
188

Luca Barbato's avatar
Luca Barbato committed
189
    switch (s->pix_fmt) {
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
    case AV_PIX_FMT_YUV420P:
    case AV_PIX_FMT_YUYV422:
    case AV_PIX_FMT_UYVY422:
    case AV_PIX_FMT_YUV422P:
    case AV_PIX_FMT_YUV440P:
    case AV_PIX_FMT_YUV444P:
    case AV_PIX_FMT_GBRP:
    case AV_PIX_FMT_GRAY8:
    case AV_PIX_FMT_GRAY16BE:
    case AV_PIX_FMT_GRAY16LE:
    case AV_PIX_FMT_YUVJ420P:
    case AV_PIX_FMT_YUVJ422P:
    case AV_PIX_FMT_YUVJ440P:
    case AV_PIX_FMT_YUVJ444P:
    case AV_PIX_FMT_YUVA420P:
205 206
    case AV_PIX_FMT_YUVA422P:
    case AV_PIX_FMT_YUVA444P:
207 208 209 210 211 212 213 214
    case AV_PIX_FMT_YUV420P9LE:
    case AV_PIX_FMT_YUV420P9BE:
    case AV_PIX_FMT_YUV420P10LE:
    case AV_PIX_FMT_YUV420P10BE:
    case AV_PIX_FMT_YUV422P9LE:
    case AV_PIX_FMT_YUV422P9BE:
    case AV_PIX_FMT_YUV422P10LE:
    case AV_PIX_FMT_YUV422P10BE:
215 216
    case AV_PIX_FMT_YUVA422P10LE:
    case AV_PIX_FMT_YUVA422P10BE:
217 218 219 220
    case AV_PIX_FMT_YUV444P9LE:
    case AV_PIX_FMT_YUV444P9BE:
    case AV_PIX_FMT_YUV444P10LE:
    case AV_PIX_FMT_YUV444P10BE:
221 222
    case AV_PIX_FMT_YUVA444P10LE:
    case AV_PIX_FMT_YUVA444P10BE:
223 224 225 226
    case AV_PIX_FMT_GBRP9LE:
    case AV_PIX_FMT_GBRP9BE:
    case AV_PIX_FMT_GBRP10LE:
    case AV_PIX_FMT_GBRP10BE:
227 228
        w_align = 16; //FIXME assume 16 pixel per macroblock
        h_align = 16 * 2; // interlaced needs 2 macroblocks height
229
        break;
230 231
    case AV_PIX_FMT_YUV411P:
    case AV_PIX_FMT_UYYVYY411:
Luca Barbato's avatar
Luca Barbato committed
232 233
        w_align = 32;
        h_align = 8;
234
        break;
235
    case AV_PIX_FMT_YUV410P:
Luca Barbato's avatar
Luca Barbato committed
236 237 238
        if (s->codec_id == AV_CODEC_ID_SVQ1) {
            w_align = 64;
            h_align = 64;
239
        }
240
    case AV_PIX_FMT_RGB555:
Luca Barbato's avatar
Luca Barbato committed
241 242 243
        if (s->codec_id == AV_CODEC_ID_RPZA) {
            w_align = 4;
            h_align = 4;
244
        }
245 246 247
    case AV_PIX_FMT_PAL8:
    case AV_PIX_FMT_BGR8:
    case AV_PIX_FMT_RGB8:
Luca Barbato's avatar
Luca Barbato committed
248 249 250
        if (s->codec_id == AV_CODEC_ID_SMC) {
            w_align = 4;
            h_align = 4;
251
        }
252
        break;
253
    case AV_PIX_FMT_BGR24:
Luca Barbato's avatar
Luca Barbato committed
254 255 256 257
        if ((s->codec_id == AV_CODEC_ID_MSZH) ||
            (s->codec_id == AV_CODEC_ID_ZLIB)) {
            w_align = 4;
            h_align = 4;
258 259
        }
        break;
260
    default:
Luca Barbato's avatar
Luca Barbato committed
261 262
        w_align = 1;
        h_align = 1;
263 264 265
        break;
    }

Luca Barbato's avatar
Luca Barbato committed
266 267
    *width  = FFALIGN(*width, w_align);
    *height = FFALIGN(*height, h_align);
268
    if (s->codec_id == AV_CODEC_ID_H264)
Luca Barbato's avatar
Luca Barbato committed
269 270
        // some of the optimized chroma MC reads one line too much
        *height += 2;
271

272
    for (i = 0; i < 4; i++)
273
        linesize_align[i] = STRIDE_ALIGN;
274 275
}

Luca Barbato's avatar
Luca Barbato committed
276 277
void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
{
278 279
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
    int chroma_shift = desc->log2_chroma_w;
280
    int linesize_align[AV_NUM_DATA_POINTERS];
281
    int align;
Luca Barbato's avatar
Luca Barbato committed
282

283
    avcodec_align_dimensions2(s, width, height, linesize_align);
Luca Barbato's avatar
Luca Barbato committed
284
    align               = FFMAX(linesize_align[0], linesize_align[3]);
285 286
    linesize_align[1] <<= chroma_shift;
    linesize_align[2] <<= chroma_shift;
Luca Barbato's avatar
Luca Barbato committed
287 288
    align               = FFMAX3(align, linesize_align[1], linesize_align[2]);
    *width              = FFALIGN(*width, align);
289 290
}

291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
                             enum AVSampleFormat sample_fmt, const uint8_t *buf,
                             int buf_size, int align)
{
    int ch, planar, needed_size, ret = 0;

    needed_size = av_samples_get_buffer_size(NULL, nb_channels,
                                             frame->nb_samples, sample_fmt,
                                             align);
    if (buf_size < needed_size)
        return AVERROR(EINVAL);

    planar = av_sample_fmt_is_planar(sample_fmt);
    if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
        if (!(frame->extended_data = av_mallocz(nb_channels *
                                                sizeof(*frame->extended_data))))
            return AVERROR(ENOMEM);
    } else {
        frame->extended_data = frame->data;
    }

    if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
                                      buf, nb_channels, frame->nb_samples,
                                      sample_fmt, align)) < 0) {
        if (frame->extended_data != frame->data)
            av_free(frame->extended_data);
        return ret;
    }
    if (frame->extended_data != frame->data) {
        for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
            frame->data[ch] = frame->extended_data[ch];
    }

    return ret;
}

327
static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
328
{
329 330
    FramePool *pool = avctx->internal->pool;
    int i, ret;
Michael Niedermayer's avatar
Michael Niedermayer committed
331

332 333
    switch (avctx->codec_type) {
    case AVMEDIA_TYPE_VIDEO: {
334
        AVPicture picture;
335 336 337 338
        int size[4] = { 0 };
        int w = frame->width;
        int h = frame->height;
        int tmpsize, unaligned;
339

340 341 342
        if (pool->format == frame->format &&
            pool->width == frame->width && pool->height == frame->height)
            return 0;
343

344
        avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
345

346
        if (!(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
Luca Barbato's avatar
Luca Barbato committed
347 348
            w += EDGE_WIDTH * 2;
            h += EDGE_WIDTH * 2;
Michael Niedermayer's avatar
Michael Niedermayer committed
349
        }
350

351 352 353
        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
354
            av_image_fill_linesizes(picture.linesize, avctx->pix_fmt, w);
355
            // increase alignment of w for next try (rhs gives the lowest bit set in w)
Luca Barbato's avatar
Luca Barbato committed
356
            w += w & ~(w - 1);
357

358
            unaligned = 0;
Luca Barbato's avatar
Luca Barbato committed
359
            for (i = 0; i < 4; i++)
360
                unaligned |= picture.linesize[i] % pool->stride_align[i];
361
        } while (unaligned);
362

363 364
        tmpsize = av_image_fill_pointers(picture.data, avctx->pix_fmt, h,
                                         NULL, picture.linesize);
365 366
        if (tmpsize < 0)
            return -1;
367

Luca Barbato's avatar
Luca Barbato committed
368 369
        for (i = 0; i < 3 && picture.data[i + 1]; i++)
            size[i] = picture.data[i + 1] - picture.data[i];
370
        size[i] = tmpsize - (picture.data[i] - picture.data[0]);
371

372 373 374 375 376 377 378 379 380 381 382 383 384 385
        for (i = 0; i < 4; i++) {
            av_buffer_pool_uninit(&pool->pools[i]);
            pool->linesize[i] = picture.linesize[i];
            if (size[i]) {
                pool->pools[i] = av_buffer_pool_init(size[i] + 16, NULL);
                if (!pool->pools[i]) {
                    ret = AVERROR(ENOMEM);
                    goto fail;
                }
            }
        }
        pool->format = frame->format;
        pool->width  = frame->width;
        pool->height = frame->height;
Michael Niedermayer's avatar
Michael Niedermayer committed
386

387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
        break;
        }
    case AVMEDIA_TYPE_AUDIO: {
        int ch     = av_get_channel_layout_nb_channels(frame->channel_layout);
        int planar = av_sample_fmt_is_planar(frame->format);
        int planes = planar ? ch : 1;

        if (pool->format == frame->format && pool->planes == planes &&
            pool->channels == ch && frame->nb_samples == pool->samples)
            return 0;

        av_buffer_pool_uninit(&pool->pools[0]);
        ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
                                         frame->nb_samples, frame->format, 0);
        if (ret < 0)
            goto fail;

        pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
        if (!pool->pools[0]) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
409

410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
        pool->format     = frame->format;
        pool->planes     = planes;
        pool->channels   = ch;
        pool->samples = frame->nb_samples;
        break;
        }
    default: av_assert0(0);
    }
    return 0;
fail:
    for (i = 0; i < 4; i++)
        av_buffer_pool_uninit(&pool->pools[i]);
    pool->format = -1;
    pool->planes = pool->channels = pool->samples = 0;
    pool->width  = pool->height = 0;
    return ret;
}
Michael Niedermayer's avatar
Michael Niedermayer committed
427

428 429 430 431 432
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
{
    FramePool *pool = avctx->internal->pool;
    int planes = pool->planes;
    int i;
433

434 435 436 437 438 439 440 441 442 443 444
    frame->linesize[0] = pool->linesize[0];

    if (planes > AV_NUM_DATA_POINTERS) {
        frame->extended_data = av_mallocz(planes * sizeof(*frame->extended_data));
        frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
        frame->extended_buf  = av_mallocz(frame->nb_extended_buf *
                                          sizeof(*frame->extended_buf));
        if (!frame->extended_data || !frame->extended_buf) {
            av_freep(&frame->extended_data);
            av_freep(&frame->extended_buf);
            return AVERROR(ENOMEM);
445
        }
446 447 448 449 450 451 452 453
    } else
        frame->extended_data = frame->data;

    for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
        frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
        if (!frame->buf[i])
            goto fail;
        frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
Michael Niedermayer's avatar
Michael Niedermayer committed
454
    }
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
    for (i = 0; i < frame->nb_extended_buf; i++) {
        frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
        if (!frame->extended_buf[i])
            goto fail;
        frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
    }

    if (avctx->debug & FF_DEBUG_BUFFERS)
        av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);

    return 0;
fail:
    av_frame_unref(frame);
    return AVERROR(ENOMEM);
}
Michael Niedermayer's avatar
Michael Niedermayer committed
470

471 472 473 474 475 476 477 478 479 480 481
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
{
    FramePool *pool = s->internal->pool;
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
    int pixel_size = desc->comp[0].step_minus1 + 1;
    int h_chroma_shift, v_chroma_shift;
    int i;

    if (pic->data[0] != NULL) {
        av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
        return -1;
482
    }
483 484

    memset(pic->data, 0, sizeof(pic->data));
485
    pic->extended_data = pic->data;
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513

    av_pix_fmt_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);

    for (i = 0; i < 4 && pool->pools[i]; i++) {
        const int h_shift = i == 0 ? 0 : h_chroma_shift;
        const int v_shift = i == 0 ? 0 : v_chroma_shift;

        pic->linesize[i] = pool->linesize[i];

        pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
        if (!pic->buf[i])
            goto fail;

        // no edge if EDGE EMU or not planar YUV
        if ((s->flags & CODEC_FLAG_EMU_EDGE) || !pool->pools[2])
            pic->data[i] = pic->buf[i]->data;
        else {
            pic->data[i] = pic->buf[i]->data +
                FFALIGN((pic->linesize[i] * EDGE_WIDTH >> v_shift) +
                        (pixel_size * EDGE_WIDTH >> h_shift), pool->stride_align[i]);
        }
    }
    for (; i < AV_NUM_DATA_POINTERS; i++) {
        pic->data[i] = NULL;
        pic->linesize[i] = 0;
    }
    if (pic->data[1] && !pic->data[2])
        avpriv_set_systematic_pal2((uint32_t *)pic->data[1], s->pix_fmt);
514

Luca Barbato's avatar
Luca Barbato committed
515
    if (s->debug & FF_DEBUG_BUFFERS)
516
        av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
517

Michael Niedermayer's avatar
Michael Niedermayer committed
518
    return 0;
519 520 521
fail:
    av_frame_unref(pic);
    return AVERROR(ENOMEM);
Michael Niedermayer's avatar
Michael Niedermayer committed
522 523
}

524
int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
525
{
526 527 528 529 530 531
    int ret;

    if ((ret = update_frame_pool(avctx, frame)) < 0)
        return ret;

#if FF_API_GET_BUFFER
532
FF_DISABLE_DEPRECATION_WARNINGS
533
    frame->type = FF_BUFFER_TYPE_INTERNAL;
534
FF_ENABLE_DEPRECATION_WARNINGS
535 536
#endif

537 538 539 540 541 542 543 544 545 546
    switch (avctx->codec_type) {
    case AVMEDIA_TYPE_VIDEO:
        return video_get_buffer(avctx, frame);
    case AVMEDIA_TYPE_AUDIO:
        return audio_get_buffer(avctx, frame);
    default:
        return -1;
    }
}

547
#if FF_API_GET_BUFFER
548
FF_DISABLE_DEPRECATION_WARNINGS
549
int avcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
550
{
551 552 553 554 555 556 557 558 559 560 561
    return avcodec_default_get_buffer2(avctx, frame, 0);
}

typedef struct CompatReleaseBufPriv {
    AVCodecContext avctx;
    AVFrame frame;
} CompatReleaseBufPriv;

static void compat_free_buffer(void *opaque, uint8_t *data)
{
    CompatReleaseBufPriv *priv = opaque;
562 563
    if (priv->avctx.release_buffer)
        priv->avctx.release_buffer(&priv->avctx, &priv->frame);
564 565 566 567 568 569 570 571
    av_freep(&priv);
}

static void compat_release_buffer(void *opaque, uint8_t *data)
{
    AVBufferRef *buf = opaque;
    av_buffer_unref(&buf);
}
572
FF_ENABLE_DEPRECATION_WARNINGS
573 574
#endif

575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
{
    AVPacket *pkt = avctx->internal->pkt;
    uint8_t *packet_sd;
    int size;
    AVFrameSideData *frame_sd;


    frame->reordered_opaque = avctx->reordered_opaque;
    if (!pkt) {
        frame->pkt_pts = AV_NOPTS_VALUE;
        return 0;
    }

    frame->pkt_pts = pkt->pts;

    /* copy the replaygain data to the output frame */
    packet_sd = av_packet_get_side_data(pkt, AV_PKT_DATA_REPLAYGAIN, &size);
    if (packet_sd) {
        frame_sd = av_frame_new_side_data(frame, AV_FRAME_DATA_REPLAYGAIN, size);
        if (!frame_sd)
            return AVERROR(ENOMEM);

        memcpy(frame_sd->data, packet_sd, size);
    }

    return 0;
}

604 605
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
{
606
    int override_dimensions = 1;
607 608
    int ret;

609 610
    switch (avctx->codec_type) {
    case AVMEDIA_TYPE_VIDEO:
611 612 613 614 615
        if (frame->width <= 0 || frame->height <= 0) {
            frame->width  = FFMAX(avctx->width, avctx->coded_width);
            frame->height = FFMAX(avctx->height, avctx->coded_height);
            override_dimensions = 0;
        }
616 617 618 619
        if (frame->format < 0)
            frame->format              = avctx->pix_fmt;
        if (!frame->sample_aspect_ratio.num)
            frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
620 621 622

        if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
            return ret;
623 624
        break;
    case AVMEDIA_TYPE_AUDIO:
625 626 627 628
        if (!frame->sample_rate)
            frame->sample_rate    = avctx->sample_rate;
        if (frame->format < 0)
            frame->format         = avctx->sample_fmt;
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
        if (!frame->channel_layout) {
            if (avctx->channel_layout) {
                 if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
                     avctx->channels) {
                     av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
                            "configuration.\n");
                     return AVERROR(EINVAL);
                 }

                frame->channel_layout = avctx->channel_layout;
            } else {
                if (avctx->channels > FF_SANE_NB_CHANNELS) {
                    av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
                           avctx->channels);
                    return AVERROR(ENOSYS);
                }

                frame->channel_layout = av_get_default_channel_layout(avctx->channels);
                if (!frame->channel_layout)
                    frame->channel_layout = (1ULL << avctx->channels) - 1;
            }
        }
651 652 653 654
        break;
    default: return AVERROR(EINVAL);
    }

655 656 657
    ret = ff_decode_frame_props(avctx, frame);
    if (ret < 0)
        return ret;
658

659
#if FF_API_GET_BUFFER
660
FF_DISABLE_DEPRECATION_WARNINGS
661 662 663 664 665 666 667 668 669 670 671
    /*
     * Wrap an old get_buffer()-allocated buffer in an bunch of AVBuffers.
     * We wrap each plane in its own AVBuffer. Each of those has a reference to
     * a dummy AVBuffer as its private data, unreffing it on free.
     * When all the planes are freed, the dummy buffer's free callback calls
     * release_buffer().
     */
    if (avctx->get_buffer) {
        CompatReleaseBufPriv *priv = NULL;
        AVBufferRef *dummy_buf = NULL;
        int planes, i, ret;
672

673 674
        if (flags & AV_GET_BUFFER_FLAG_REF)
            frame->reference    = 1;
675

676 677 678
        ret = avctx->get_buffer(avctx, frame);
        if (ret < 0)
            return ret;
679

680 681 682 683 684 685 686 687 688 689 690 691 692 693
        /* return if the buffers are already set up
         * this would happen e.g. when a custom get_buffer() calls
         * avcodec_default_get_buffer
         */
        if (frame->buf[0])
            return 0;

        priv = av_mallocz(sizeof(*priv));
        if (!priv) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        priv->avctx = *avctx;
        priv->frame = *frame;
694

695 696 697 698
        dummy_buf = av_buffer_create(NULL, 0, compat_free_buffer, priv, 0);
        if (!dummy_buf) {
            ret = AVERROR(ENOMEM);
            goto fail;
699
        }
700

701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
#define WRAP_PLANE(ref_out, data, data_size)                            \
do {                                                                    \
    AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf);                  \
    if (!dummy_ref) {                                                   \
        ret = AVERROR(ENOMEM);                                          \
        goto fail;                                                      \
    }                                                                   \
    ref_out = av_buffer_create(data, data_size, compat_release_buffer,  \
                               dummy_ref, 0);                           \
    if (!ref_out) {                                                     \
        av_frame_unref(frame);                                          \
        ret = AVERROR(ENOMEM);                                          \
        goto fail;                                                      \
    }                                                                   \
} while (0)

        if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);

720
            planes = av_pix_fmt_count_planes(frame->format);
721 722
            /* workaround for AVHWAccel plane count of 0, buf[0] is used as
               check for allocated buffers: make libavcodec happy */
723
            if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
724
                planes = 1;
725
            if (!desc || planes <= 0) {
726 727 728
                ret = AVERROR(EINVAL);
                goto fail;
            }
729

730
            for (i = 0; i < planes; i++) {
731 732
                int v_shift    = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
                int plane_size = (frame->height >> v_shift) * frame->linesize[i];
733

734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
                WRAP_PLANE(frame->buf[i], frame->data[i], plane_size);
            }
        } else {
            int planar = av_sample_fmt_is_planar(frame->format);
            planes = planar ? avctx->channels : 1;

            if (planes > FF_ARRAY_ELEMS(frame->buf)) {
                frame->nb_extended_buf = planes - FF_ARRAY_ELEMS(frame->buf);
                frame->extended_buf = av_malloc(sizeof(*frame->extended_buf) *
                                                frame->nb_extended_buf);
                if (!frame->extended_buf) {
                    ret = AVERROR(ENOMEM);
                    goto fail;
                }
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
749

750 751 752
            for (i = 0; i < FFMIN(planes, FF_ARRAY_ELEMS(frame->buf)); i++)
                WRAP_PLANE(frame->buf[i], frame->extended_data[i], frame->linesize[0]);

753
            for (i = 0; i < frame->nb_extended_buf; i++)
754 755 756 757 758 759
                WRAP_PLANE(frame->extended_buf[i],
                           frame->extended_data[i + FF_ARRAY_ELEMS(frame->buf)],
                           frame->linesize[0]);
        }

        av_buffer_unref(&dummy_buf);
760

761 762 763
        frame->width  = avctx->width;
        frame->height = avctx->height;

764
        return 0;
765

766 767 768 769 770
fail:
        avctx->release_buffer(avctx, frame);
        av_freep(&priv);
        av_buffer_unref(&dummy_buf);
        return ret;
771
    }
772
FF_ENABLE_DEPRECATION_WARNINGS
773 774
#endif

775 776
    ret = avctx->get_buffer2(avctx, frame, flags);

777
    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions) {
778 779 780 781 782
        frame->width  = avctx->width;
        frame->height = avctx->height;
    }

    return ret;
783 784 785 786
}

int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
{
787
    AVFrame *tmp;
788
    int ret;
789

790 791 792 793
    av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);

    if (!frame->data[0])
        return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
794

795 796
    if (av_frame_is_writable(frame))
        return ff_decode_frame_props(avctx, frame);
797

798 799 800 801 802
    tmp = av_frame_alloc();
    if (!tmp)
        return AVERROR(ENOMEM);

    av_frame_move_ref(tmp, frame);
803 804 805

    ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
    if (ret < 0) {
806
        av_frame_free(&tmp);
807
        return ret;
808
    }
809

810 811
    av_frame_copy(frame, tmp);
    av_frame_free(&tmp);
812

813 814 815
    return 0;
}

816 817 818 819 820 821 822 823 824
#if FF_API_GET_BUFFER
void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)
{
    av_frame_unref(pic);
}

int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic)
{
    av_assert0(0);
825
    return AVERROR_BUG;
826 827 828
}
#endif

Luca Barbato's avatar
Luca Barbato committed
829 830
int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
{
831 832
    int i;

Luca Barbato's avatar
Luca Barbato committed
833 834 835 836
    for (i = 0; i < count; i++) {
        int r = func(c, (char *)arg + i * size);
        if (ret)
            ret[i] = r;
837 838 839 840
    }
    return 0;
}

Luca Barbato's avatar
Luca Barbato committed
841 842
int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
{
843 844
    int i;

Luca Barbato's avatar
Luca Barbato committed
845 846 847 848
    for (i = 0; i < count; i++) {
        int r = func(c, arg, i, 0);
        if (ret)
            ret[i] = r;
849 850 851 852
    }
    return 0;
}

853 854 855
static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
856
    return desc->flags & AV_PIX_FMT_FLAG_HWACCEL;
857 858
}

859
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Luca Barbato's avatar
Luca Barbato committed
860
{
861
    while (*fmt != AV_PIX_FMT_NONE && is_hwaccel_pix_fmt(*fmt))
862
        ++fmt;
Michael Niedermayer's avatar
Michael Niedermayer committed
863 864 865
    return fmt[0];
}

866
#if FF_API_AVFRAME_LAVC
867
void avcodec_get_frame_defaults(AVFrame *frame)
Luca Barbato's avatar
Luca Barbato committed
868
{
869 870 871
    if (frame->extended_data != frame->data)
        av_freep(&frame->extended_data);

872
    memset(frame, 0, sizeof(AVFrame));
873

874 875 876 877
    frame->pts                 = AV_NOPTS_VALUE;
    frame->key_frame           = 1;
    frame->sample_aspect_ratio = (AVRational) {0, 1 };
    frame->format              = -1; /* unknown */
878
    frame->extended_data       = frame->data;
879 880
}

Luca Barbato's avatar
Luca Barbato committed
881 882
AVFrame *avcodec_alloc_frame(void)
{
883
    AVFrame *frame = av_mallocz(sizeof(AVFrame));
884

885
    if (frame == NULL)
Luca Barbato's avatar
Luca Barbato committed
886
        return NULL;
887

888
FF_DISABLE_DEPRECATION_WARNINGS
889
    avcodec_get_frame_defaults(frame);
890
FF_ENABLE_DEPRECATION_WARNINGS
891

892
    return frame;
Michael Niedermayer's avatar
Michael Niedermayer committed
893 894
}

895 896
void avcodec_free_frame(AVFrame **frame)
{
897
    av_frame_free(frame);
898
}
899
#endif
900

901
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Fabrice Bellard's avatar
Fabrice Bellard committed
902
{
903
    int ret = 0;
904 905
    AVDictionary *tmp = NULL;

906 907 908
    if (avcodec_is_open(avctx))
        return 0;

909 910 911 912 913 914
    if ((!codec && !avctx->codec)) {
        av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n");
        return AVERROR(EINVAL);
    }
    if ((codec && avctx->codec && codec != avctx->codec)) {
        av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
Luca Barbato's avatar
Luca Barbato committed
915
                                    "but %s passed to avcodec_open2().\n", avctx->codec->name, codec->name);
916 917 918 919 920
        return AVERROR(EINVAL);
    }
    if (!codec)
        codec = avctx->codec;

921 922 923
    if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
        return AVERROR(EINVAL);

924 925
    if (options)
        av_dict_copy(&tmp, *options, 0);
926

927
    /* If there is a user-supplied mutex locking routine, call it. */
928 929
    if (lockmgr_cb) {
        if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
930 931 932
            return -1;
    }

933
    entangled_thread_counter++;
Luca Barbato's avatar
Luca Barbato committed
934
    if (entangled_thread_counter != 1) {
935
        av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
936
        ret = -1;
937 938
        goto end;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
939

940 941 942 943 944 945
    avctx->internal = av_mallocz(sizeof(AVCodecInternal));
    if (!avctx->internal) {
        ret = AVERROR(ENOMEM);
        goto end;
    }

946 947 948 949 950 951
    avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));
    if (!avctx->internal->pool) {
        ret = AVERROR(ENOMEM);
        goto free_and_end;
    }

952 953 954 955 956 957
    avctx->internal->to_free = av_frame_alloc();
    if (!avctx->internal->to_free) {
        ret = AVERROR(ENOMEM);
        goto free_and_end;
    }

958
    if (codec->priv_data_size > 0) {
959
        if (!avctx->priv_data) {
Luca Barbato's avatar
Luca Barbato committed
960 961 962 963 964 965 966 967 968
            avctx->priv_data = av_mallocz(codec->priv_data_size);
            if (!avctx->priv_data) {
                ret = AVERROR(ENOMEM);
                goto end;
            }
            if (codec->priv_class) {
                *(const AVClass **)avctx->priv_data = codec->priv_class;
                av_opt_set_defaults(avctx->priv_data);
            }
969
        }
Luca Barbato's avatar
Luca Barbato committed
970 971
        if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
            goto free_and_end;
972 973 974
    } else {
        avctx->priv_data = NULL;
    }
975 976
    if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
        goto free_and_end;
977

978
    if (avctx->coded_width && avctx->coded_height && !avctx->width && !avctx->height)
979
        ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
Luca Barbato's avatar
Luca Barbato committed
980
    else if (avctx->width && avctx->height)
981 982 983
        ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
    if (ret < 0)
        goto free_and_end;
984

985 986 987 988
    if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
        && (  av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
           || av_image_check_size(avctx->width,       avctx->height,       0, avctx) < 0)) {
        av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
989
        ff_set_dimensions(avctx, 0, 0);
990 991
    }

992
    /* if the decoder init function was already called previously,
Luca Barbato's avatar
Luca Barbato committed
993
     * free the already allocated subtitle_header before overwriting it */
994
    if (av_codec_is_decoder(codec))
995 996
        av_freep(&avctx->subtitle_header);

997
    if (avctx->channels > FF_SANE_NB_CHANNELS) {
998
        ret = AVERROR(EINVAL);
999
        goto free_and_end;
1000 1001
    }

1002
    avctx->codec = codec;
1003
    if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
1004
        avctx->codec_id == AV_CODEC_ID_NONE) {
1005 1006 1007
        avctx->codec_type = codec->type;
        avctx->codec_id   = codec->id;
    }
1008
    if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
Luca Barbato's avatar
Luca Barbato committed
1009
                                         && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
1010
        av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
1011
        ret = AVERROR(EINVAL);
1012
        goto free_and_end;
1013
    }
1014
    avctx->frame_number = 0;
1015

1016 1017 1018 1019 1020 1021
    if (avctx->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
        ret = AVERROR_EXPERIMENTAL;
        goto free_and_end;
    }

1022 1023 1024 1025 1026 1027
    if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
        (!avctx->time_base.num || !avctx->time_base.den)) {
        avctx->time_base.num = 1;
        avctx->time_base.den = avctx->sample_rate;
    }

1028
    if (HAVE_THREADS) {
1029
        ret = ff_thread_init(avctx);
1030 1031 1032 1033
        if (ret < 0) {
            goto free_and_end;
        }
    }
1034 1035
    if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))
        avctx->thread_count = 1;
1036

1037
    if (av_codec_is_encoder(avctx->codec)) {
1038
        int i;
1039
        if (avctx->codec->sample_fmts) {
1040
            for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
Justin Ruggles's avatar
Justin Ruggles committed
1041 1042
                if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
                    break;
1043 1044 1045 1046 1047 1048 1049
                if (avctx->channels == 1 &&
                    av_get_planar_sample_fmt(avctx->sample_fmt) ==
                    av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
                    avctx->sample_fmt = avctx->codec->sample_fmts[i];
                    break;
                }
            }
Justin Ruggles's avatar
Justin Ruggles committed
1050 1051 1052 1053 1054
            if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
                av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
                ret = AVERROR(EINVAL);
                goto free_and_end;
            }
1055
        }
1056
        if (avctx->codec->pix_fmts) {
1057
            for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
1058 1059
                if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
                    break;
1060
            if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE) {
1061 1062 1063 1064 1065
                av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
                ret = AVERROR(EINVAL);
                goto free_and_end;
            }
        }
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
        if (avctx->codec->supported_samplerates) {
            for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
                if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
                    break;
            if (avctx->codec->supported_samplerates[i] == 0) {
                av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
                ret = AVERROR(EINVAL);
                goto free_and_end;
            }
        }
        if (avctx->codec->channel_layouts) {
            if (!avctx->channel_layout) {
                av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
            } else {
                for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
                    if (avctx->channel_layout == avctx->codec->channel_layouts[i])
                        break;
                if (avctx->codec->channel_layouts[i] == 0) {
                    av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
                    ret = AVERROR(EINVAL);
                    goto free_and_end;
                }
            }
        }
1090 1091 1092 1093 1094 1095
        if (avctx->channel_layout && avctx->channels) {
            if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
                av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
                ret = AVERROR(EINVAL);
                goto free_and_end;
            }
1096 1097
        } else if (avctx->channel_layout) {
            avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
1098
        }
1099 1100 1101

        if (!avctx->rc_initial_buffer_occupancy)
            avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3 / 4;
1102
    }
1103

Luca Barbato's avatar
Luca Barbato committed
1104
    if (avctx->codec->init && !(avctx->active_thread_type & FF_THREAD_FRAME)) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1105 1106
        ret = avctx->codec->init(avctx);
        if (ret < 0) {
1107
            goto free_and_end;
Michael Niedermayer's avatar
Michael Niedermayer committed
1108
        }
1109
    }
1110 1111 1112

    if (av_codec_is_decoder(avctx->codec)) {
        /* validate channel layout from the decoder */
1113 1114 1115 1116 1117 1118 1119 1120 1121
        if (avctx->channel_layout) {
            int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
            if (!avctx->channels)
                avctx->channels = channels;
            else if (channels != avctx->channels) {
                av_log(avctx, AV_LOG_WARNING,
                       "channel layout does not match number of channels\n");
                avctx->channel_layout = 0;
            }
1122
        }
1123 1124 1125 1126 1127
        if (avctx->channels && avctx->channels < 0 ||
            avctx->channels > FF_SANE_NB_CHANNELS) {
            ret = AVERROR(EINVAL);
            goto free_and_end;
        }
1128
    }
1129 1130
end:
    entangled_thread_counter--;
1131 1132

    /* Release any user-supplied mutex. */
1133 1134
    if (lockmgr_cb) {
        (*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
1135
    }
1136 1137 1138 1139 1140
    if (options) {
        av_dict_free(options);
        *options = tmp;
    }

1141
    return ret;
1142
free_and_end:
1143
    av_dict_free(&tmp);
1144
    av_freep(&avctx->priv_data);
1145 1146
    if (avctx->internal) {
        av_frame_free(&avctx->internal->to_free);
1147
        av_freep(&avctx->internal->pool);
1148
    }
1149
    av_freep(&avctx->internal);
Luca Barbato's avatar
Luca Barbato committed
1150
    avctx->codec = NULL;
1151
    goto end;
Fabrice Bellard's avatar
Fabrice Bellard committed
1152 1153
}

1154
int ff_alloc_packet(AVPacket *avpkt, int size)
Fabrice Bellard's avatar
Fabrice Bellard committed
1155
{
1156 1157 1158 1159
    if (size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
        return AVERROR(EINVAL);

    if (avpkt->data) {
1160 1161
        AVBufferRef *buf = avpkt->buf;
#if FF_API_DESTRUCT_PACKET
1162
FF_DISABLE_DEPRECATION_WARNINGS
1163
        void *destruct = avpkt->destruct;
1164
FF_ENABLE_DEPRECATION_WARNINGS
1165
#endif
1166 1167 1168 1169 1170

        if (avpkt->size < size)
            return AVERROR(EINVAL);

        av_init_packet(avpkt);
1171
#if FF_API_DESTRUCT_PACKET
1172
FF_DISABLE_DEPRECATION_WARNINGS
1173
        avpkt->destruct = destruct;
1174
FF_ENABLE_DEPRECATION_WARNINGS
1175 1176
#endif
        avpkt->buf      = buf;
Luca Barbato's avatar
Luca Barbato committed
1177
        avpkt->size     = size;
1178 1179 1180
        return 0;
    } else {
        return av_new_packet(avpkt, size);
1181
    }
1182 1183
}

1184 1185 1186 1187 1188 1189 1190 1191
/**
 * Pad last frame with silence.
 */
static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
{
    AVFrame *frame = NULL;
    int ret;

1192
    if (!(frame = av_frame_alloc()))
1193 1194
        return AVERROR(ENOMEM);

1195 1196 1197 1198 1199
    frame->format         = src->format;
    frame->channel_layout = src->channel_layout;
    frame->nb_samples     = s->frame_size;
    ret = av_frame_get_buffer(frame, 32);
    if (ret < 0)
1200 1201
        goto fail;

1202 1203
    ret = av_frame_copy_props(frame, src);
    if (ret < 0)
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
        goto fail;

    if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
                               src->nb_samples, s->channels, s->sample_fmt)) < 0)
        goto fail;
    if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
                                      frame->nb_samples - src->nb_samples,
                                      s->channels, s->sample_fmt)) < 0)
        goto fail;

    *dst = frame;

    return 0;

fail:
1219
    av_frame_free(&frame);
1220 1221 1222
    return ret;
}

1223 1224 1225 1226 1227
int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
                                              AVPacket *avpkt,
                                              const AVFrame *frame,
                                              int *got_packet_ptr)
{
1228
    AVFrame tmp;
1229
    AVFrame *padded_frame = NULL;
1230 1231 1232
    int ret;
    int user_packet = !!avpkt->data;

1233 1234
    *got_packet_ptr = 0;

1235
    if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
1236
        av_free_packet(avpkt);
1237
        av_init_packet(avpkt);
1238
        return 0;
1239 1240
    }

1241 1242 1243 1244 1245
    /* ensure that extended_data is properly set */
    if (frame && !frame->extended_data) {
        if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
            avctx->channels > AV_NUM_DATA_POINTERS) {
            av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
Luca Barbato's avatar
Luca Barbato committed
1246
                                        "with more than %d channels, but extended_data is not set.\n",
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
                   AV_NUM_DATA_POINTERS);
            return AVERROR(EINVAL);
        }
        av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");

        tmp = *frame;
        tmp.extended_data = tmp.data;
        frame = &tmp;
    }

1257 1258 1259
    /* check for valid frame size */
    if (frame) {
        if (avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1260
            if (frame->nb_samples > avctx->frame_size)
1261 1262
                return AVERROR(EINVAL);
        } else if (!(avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
            if (frame->nb_samples < avctx->frame_size &&
                !avctx->internal->last_audio_frame) {
                ret = pad_last_frame(avctx, &padded_frame, frame);
                if (ret < 0)
                    return ret;

                frame = padded_frame;
                avctx->internal->last_audio_frame = 1;
            }

1273 1274 1275 1276
            if (frame->nb_samples != avctx->frame_size) {
                ret = AVERROR(EINVAL);
                goto end;
            }
1277 1278 1279
        }
    }

1280 1281 1282
    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
    if (!ret) {
        if (*got_packet_ptr) {
1283
            if (!(avctx->codec->capabilities & CODEC_CAP_DELAY)) {
1284 1285 1286 1287 1288
                if (avpkt->pts == AV_NOPTS_VALUE)
                    avpkt->pts = frame->pts;
                if (!avpkt->duration)
                    avpkt->duration = ff_samples_to_time_base(avctx,
                                                              frame->nb_samples);
1289 1290
            }
            avpkt->dts = avpkt->pts;
1291 1292
        } else {
            avpkt->size = 0;
1293 1294
        }

1295
        if (!user_packet && avpkt->size) {
1296 1297 1298
            ret = av_buffer_realloc(&avpkt->buf, avpkt->size);
            if (ret >= 0)
                avpkt->data = avpkt->buf->data;
1299 1300
        }

1301
        avctx->frame_number++;
1302
    }
1303

1304
    if (ret < 0 || !*got_packet_ptr) {
1305
        av_free_packet(avpkt);
1306
        av_init_packet(avpkt);
1307
        goto end;
1308
    }
1309

1310
    /* NOTE: if we add any audio encoders which output non-keyframe packets,
Luca Barbato's avatar
Luca Barbato committed
1311 1312
     *       this needs to be moved to the encoders, but for now we can do it
     *       here to simplify things */
1313 1314
    avpkt->flags |= AV_PKT_FLAG_KEY;

1315
end:
1316
    av_frame_free(&padded_frame);
1317

1318
    return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
1319 1320
}

1321 1322 1323 1324 1325 1326 1327 1328
int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
                                              AVPacket *avpkt,
                                              const AVFrame *frame,
                                              int *got_packet_ptr)
{
    int ret;
    int user_packet = !!avpkt->data;

1329 1330
    *got_packet_ptr = 0;

1331
    if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
1332
        av_free_packet(avpkt);
1333
        av_init_packet(avpkt);
Luca Barbato's avatar
Luca Barbato committed
1334
        avpkt->size = 0;
1335
        return 0;
1336 1337 1338 1339 1340
    }

    if (av_image_check_size(avctx->width, avctx->height, 0, avctx))
        return AVERROR(EINVAL);

1341
    av_assert0(avctx->codec->encode2);
1342

1343 1344 1345 1346 1347 1348
    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
    if (!ret) {
        if (!*got_packet_ptr)
            avpkt->size = 0;
        else if (!(avctx->codec->capabilities & CODEC_CAP_DELAY))
            avpkt->pts = avpkt->dts = frame->pts;
1349

1350
        if (!user_packet && avpkt->size) {
1351 1352 1353
            ret = av_buffer_realloc(&avpkt->buf, avpkt->size);
            if (ret >= 0)
                avpkt->data = avpkt->buf->data;
1354 1355
        }

1356
        avctx->frame_number++;
1357
    }
1358

1359 1360 1361
    if (ret < 0 || !*got_packet_ptr)
        av_free_packet(avpkt);

1362 1363
    emms_c();
    return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
1364 1365
}

1366
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
1367 1368 1369
                            const AVSubtitle *sub)
{
    int ret;
Luca Barbato's avatar
Luca Barbato committed
1370
    if (sub->start_display_time) {
1371 1372 1373
        av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
        return -1;
    }
Luca Barbato's avatar
Luca Barbato committed
1374
    if (sub->num_rects == 0 || !sub->rects)
1375
        return -1;
1376
    ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
1377 1378 1379 1380
    avctx->frame_number++;
    return ret;
}

1381
static int apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
1382
{
1383
    int size = 0, ret;
1384 1385 1386 1387
    const uint8_t *data;
    uint32_t flags;

    data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
    if (!data)
        return 0;

    if (!(avctx->codec->capabilities & CODEC_CAP_PARAM_CHANGE)) {
        av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
               "changes, but PARAM_CHANGE side data was sent to it.\n");
        return AVERROR(EINVAL);
    }

    if (size < 4)
        goto fail;

1400 1401
    flags = bytestream_get_le32(&data);
    size -= 4;
1402

1403
    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
1404 1405
        if (size < 4)
            goto fail;
1406 1407 1408 1409 1410
        avctx->channels = bytestream_get_le32(&data);
        size -= 4;
    }
    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
        if (size < 8)
1411
            goto fail;
1412 1413 1414 1415
        avctx->channel_layout = bytestream_get_le64(&data);
        size -= 8;
    }
    if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
1416 1417
        if (size < 4)
            goto fail;
1418 1419 1420 1421 1422
        avctx->sample_rate = bytestream_get_le32(&data);
        size -= 4;
    }
    if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
        if (size < 8)
1423
            goto fail;
1424 1425 1426
        avctx->width  = bytestream_get_le32(&data);
        avctx->height = bytestream_get_le32(&data);
        size -= 8;
1427 1428 1429
        ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
        if (ret < 0)
            return ret;
1430
    }
1431 1432 1433 1434 1435

    return 0;
fail:
    av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
    return AVERROR_INVALIDDATA;
1436 1437
}

1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
{
    int ret;

    /* move the original frame to our backup */
    av_frame_unref(avci->to_free);
    av_frame_move_ref(avci->to_free, frame);

    /* now copy everything except the AVBufferRefs back
     * note that we make a COPY of the side data, so calling av_frame_free() on
     * the caller's frame will work properly */
    ret = av_frame_copy_props(frame, avci->to_free);
    if (ret < 0)
        return ret;

    memcpy(frame->data,     avci->to_free->data,     sizeof(frame->data));
    memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
    if (avci->to_free->extended_data != avci->to_free->data) {
        int planes = av_get_channel_layout_nb_channels(avci->to_free->channel_layout);
        int size   = planes * sizeof(*frame->extended_data);

        if (!size) {
            av_frame_unref(frame);
            return AVERROR_BUG;
        }

        frame->extended_data = av_malloc(size);
        if (!frame->extended_data) {
            av_frame_unref(frame);
            return AVERROR(ENOMEM);
        }
        memcpy(frame->extended_data, avci->to_free->extended_data,
               size);
    } else
        frame->extended_data = frame->data;

    frame->format         = avci->to_free->format;
    frame->width          = avci->to_free->width;
    frame->height         = avci->to_free->height;
    frame->channel_layout = avci->to_free->channel_layout;
    frame->nb_samples     = avci->to_free->nb_samples;

    return 0;
}

1483
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
Luca Barbato's avatar
Luca Barbato committed
1484 1485
                                              int *got_picture_ptr,
                                              AVPacket *avpkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
1486
{
1487
    AVCodecInternal *avci = avctx->internal;
Fabrice Bellard's avatar
Fabrice Bellard committed
1488
    int ret;
1489

Luca Barbato's avatar
Luca Barbato committed
1490 1491
    *got_picture_ptr = 0;
    if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
1492
        return -1;
1493

1494
    avctx->internal->pkt = avpkt;
1495 1496 1497 1498 1499 1500
    ret = apply_param_change(avctx, avpkt);
    if (ret < 0) {
        av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
        if (avctx->err_recognition & AV_EF_EXPLODE)
            return ret;
    }
1501

1502
    av_frame_unref(picture);
1503

Luca Barbato's avatar
Luca Barbato committed
1504 1505 1506 1507
    if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
        if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
            ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
                                         avpkt);
1508 1509
        else {
            ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
Luca Barbato's avatar
Luca Barbato committed
1510
                                       avpkt);
1511 1512 1513 1514 1515 1516 1517 1518
            picture->pkt_dts = avpkt->dts;
            /* get_buffer is supposed to set frame parameters */
            if (!(avctx->codec->capabilities & CODEC_CAP_DR1)) {
                picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
                picture->width               = avctx->width;
                picture->height              = avctx->height;
                picture->format              = avctx->pix_fmt;
            }
1519
        }
1520

Diego Biurrun's avatar
Diego Biurrun committed
1521
        emms_c(); //needed to avoid an emms_c() call before every return;
1522

1523 1524
        if (*got_picture_ptr) {
            if (!avctx->refcounted_frames) {
1525 1526 1527
                int err = unrefcount_frame(avci, picture);
                if (err < 0)
                    return err;
1528 1529
            }

1530
            avctx->frame_number++;
1531 1532
        } else
            av_frame_unref(picture);
Luca Barbato's avatar
Luca Barbato committed
1533 1534
    } else
        ret = 0;
1535

Fabrice Bellard's avatar
Fabrice Bellard committed
1536 1537 1538
    return ret;
}

1539 1540 1541 1542 1543
int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
                                              AVFrame *frame,
                                              int *got_frame_ptr,
                                              AVPacket *avpkt)
{
1544
    AVCodecInternal *avci = avctx->internal;
1545 1546 1547
    int ret = 0;

    *got_frame_ptr = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1548

1549
    avctx->internal->pkt = avpkt;
1550

1551 1552 1553 1554 1555
    if (!avpkt->data && avpkt->size) {
        av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
        return AVERROR(EINVAL);
    }

1556 1557 1558 1559 1560 1561
    ret = apply_param_change(avctx, avpkt);
    if (ret < 0) {
        av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
        if (avctx->err_recognition & AV_EF_EXPLODE)
            return ret;
    }
1562

1563
    av_frame_unref(frame);
1564

1565 1566 1567 1568 1569
    if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size) {
        ret = avctx->codec->decode(avctx, frame, got_frame_ptr, avpkt);
        if (ret >= 0 && *got_frame_ptr) {
            avctx->frame_number++;
            frame->pkt_dts = avpkt->dts;
1570 1571
            if (frame->format == AV_SAMPLE_FMT_NONE)
                frame->format = avctx->sample_fmt;
1572 1573

            if (!avctx->refcounted_frames) {
1574 1575 1576
                int err = unrefcount_frame(avci, frame);
                if (err < 0)
                    return err;
1577
            }
1578
        } else
1579
            av_frame_unref(frame);
1580
    }
1581 1582


Fabrice Bellard's avatar
Fabrice Bellard committed
1583 1584 1585
    return ret;
}

1586
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
Luca Barbato's avatar
Luca Barbato committed
1587 1588
                             int *got_sub_ptr,
                             AVPacket *avpkt)
1589 1590 1591
{
    int ret;

1592
    avctx->internal->pkt = avpkt;
1593
    *got_sub_ptr = 0;
1594
    ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
1595 1596 1597 1598 1599
    if (*got_sub_ptr)
        avctx->frame_number++;
    return ret;
}

1600 1601 1602 1603
void avsubtitle_free(AVSubtitle *sub)
{
    int i;

Luca Barbato's avatar
Luca Barbato committed
1604
    for (i = 0; i < sub->num_rects; i++) {
1605 1606 1607 1608 1609 1610 1611
        av_freep(&sub->rects[i]->pict.data[0]);
        av_freep(&sub->rects[i]->pict.data[1]);
        av_freep(&sub->rects[i]->pict.data[2]);
        av_freep(&sub->rects[i]->pict.data[3]);
        av_freep(&sub->rects[i]->text);
        av_freep(&sub->rects[i]->ass);
        av_freep(&sub->rects[i]);
1612 1613
    }

1614
    av_freep(&sub->rects);
1615 1616 1617 1618

    memset(sub, 0, sizeof(AVSubtitle));
}

1619
av_cold int avcodec_close(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
1620
{
1621
    /* If there is a user-supplied mutex locking routine, call it. */
1622 1623
    if (lockmgr_cb) {
        if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
1624 1625 1626
            return -1;
    }

1627
    entangled_thread_counter++;
Luca Barbato's avatar
Luca Barbato committed
1628
    if (entangled_thread_counter != 1) {
1629 1630 1631 1632 1633
        av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
        entangled_thread_counter--;
        return -1;
    }

1634
    if (avcodec_is_open(avctx)) {
1635 1636
        FramePool *pool = avctx->internal->pool;
        int i;
1637
        if (HAVE_THREADS && avctx->internal->thread_ctx)
1638 1639 1640 1641
            ff_thread_free(avctx);
        if (avctx->codec && avctx->codec->close)
            avctx->codec->close(avctx);
        avctx->coded_frame = NULL;
1642
        av_frame_free(&avctx->internal->to_free);
1643 1644 1645
        for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
            av_buffer_pool_uninit(&pool->pools[i]);
        av_freep(&avctx->internal->pool);
1646 1647 1648 1649
        av_freep(&avctx->internal);
    }

    if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1650 1651
        av_opt_free(avctx->priv_data);
    av_opt_free(avctx);
1652
    av_freep(&avctx->priv_data);
1653
    if (av_codec_is_encoder(avctx->codec))
1654
        av_freep(&avctx->extradata);
Fabrice Bellard's avatar
Fabrice Bellard committed
1655
    avctx->codec = NULL;
1656
    avctx->active_thread_type = 0;
1657
    entangled_thread_counter--;
1658 1659

    /* Release any user-supplied mutex. */
1660 1661
    if (lockmgr_cb) {
        (*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
1662
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1663 1664 1665
    return 0;
}

1666
static AVCodec *find_encdec(enum AVCodecID id, int encoder)
Fabrice Bellard's avatar
Fabrice Bellard committed
1667
{
Luca Barbato's avatar
Luca Barbato committed
1668
    AVCodec *p, *experimental = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
1669 1670
    p = first_avcodec;
    while (p) {
1671 1672
        if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
            p->id == id) {
1673 1674 1675 1676 1677
            if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
                experimental = p;
            } else
                return p;
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1678 1679
        p = p->next;
    }
1680
    return experimental;
Fabrice Bellard's avatar
Fabrice Bellard committed
1681 1682
}

1683 1684 1685 1686 1687
AVCodec *avcodec_find_encoder(enum AVCodecID id)
{
    return find_encdec(id, 1);
}

1688 1689 1690
AVCodec *avcodec_find_encoder_by_name(const char *name)
{
    AVCodec *p;
1691 1692
    if (!name)
        return NULL;
1693 1694
    p = first_avcodec;
    while (p) {
Luca Barbato's avatar
Luca Barbato committed
1695
        if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
1696 1697 1698 1699 1700 1701
            return p;
        p = p->next;
    }
    return NULL;
}

1702
AVCodec *avcodec_find_decoder(enum AVCodecID id)
Fabrice Bellard's avatar
Fabrice Bellard committed
1703
{
1704
    return find_encdec(id, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
1705 1706 1707 1708 1709
}

AVCodec *avcodec_find_decoder_by_name(const char *name)
{
    AVCodec *p;
1710 1711
    if (!name)
        return NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
1712 1713
    p = first_avcodec;
    while (p) {
Luca Barbato's avatar
Luca Barbato committed
1714
        if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
1715 1716 1717 1718 1719 1720
            return p;
        p = p->next;
    }
    return NULL;
}

1721
static int get_bit_rate(AVCodecContext *ctx)
1722 1723 1724 1725
{
    int bit_rate;
    int bits_per_sample;

Luca Barbato's avatar
Luca Barbato committed
1726
    switch (ctx->codec_type) {
1727
    case AVMEDIA_TYPE_VIDEO:
1728 1729 1730
    case AVMEDIA_TYPE_DATA:
    case AVMEDIA_TYPE_SUBTITLE:
    case AVMEDIA_TYPE_ATTACHMENT:
1731 1732
        bit_rate = ctx->bit_rate;
        break;
1733
    case AVMEDIA_TYPE_AUDIO:
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
        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;
    default:
        bit_rate = 0;
        break;
    }
    return bit_rate;
}

1744 1745 1746 1747
size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
{
    int i, len, ret = 0;

1748 1749 1750 1751 1752
#define TAG_PRINT(x)                                              \
    (((x) >= '0' && (x) <= '9') ||                                \
     ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') ||  \
     ((x) == '.' || (x) == ' '))

1753 1754
    for (i = 0; i < 4; i++) {
        len = snprintf(buf, buf_size,
1755
                       TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
Luca Barbato's avatar
Luca Barbato committed
1756 1757 1758 1759
        buf        += len;
        buf_size    = buf_size > len ? buf_size - len : 0;
        ret        += len;
        codec_tag >>= 8;
1760 1761 1762 1763
    }
    return ret;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1764 1765 1766
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
{
    const char *codec_name;
1767
    const char *profile = NULL;
1768
    const AVCodec *p;
Fabrice Bellard's avatar
Fabrice Bellard committed
1769
    char buf1[32];
Fabrice Bellard's avatar
Fabrice Bellard committed
1770
    int bitrate;
1771
    AVRational display_aspect_ratio;
Fabrice Bellard's avatar
Fabrice Bellard committed
1772

1773 1774 1775
    if (enc->codec)
        p = enc->codec;
    else if (encode)
Fabrice Bellard's avatar
Fabrice Bellard committed
1776 1777 1778 1779 1780 1781
        p = avcodec_find_encoder(enc->codec_id);
    else
        p = avcodec_find_decoder(enc->codec_id);

    if (p) {
        codec_name = p->name;
1782
        profile = av_get_profile_name(p, enc->profile);
1783
    } else if (enc->codec_id == AV_CODEC_ID_MPEG2TS) {
1784
        /* fake mpeg2 transport stream codec (currently not
Luca Barbato's avatar
Luca Barbato committed
1785
         * registered) */
1786
        codec_name = "mpeg2ts";
Fabrice Bellard's avatar
Fabrice Bellard committed
1787 1788 1789 1790
    } else if (enc->codec_name[0] != '\0') {
        codec_name = enc->codec_name;
    } else {
        /* output avi tags */
1791 1792 1793
        char tag_buf[32];
        av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
        snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag);
Fabrice Bellard's avatar
Fabrice Bellard committed
1794 1795 1796
        codec_name = buf1;
    }

Luca Barbato's avatar
Luca Barbato committed
1797
    switch (enc->codec_type) {
1798
    case AVMEDIA_TYPE_VIDEO:
Fabrice Bellard's avatar
Fabrice Bellard committed
1799 1800
        snprintf(buf, buf_size,
                 "Video: %s%s",
1801
                 codec_name, enc->mb_decision ? " (hq)" : "");
1802 1803 1804
        if (profile)
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     " (%s)", profile);
1805
        if (enc->pix_fmt != AV_PIX_FMT_NONE) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1806 1807
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", %s",
1808
                     av_get_pix_fmt_name(enc->pix_fmt));
Fabrice Bellard's avatar
Fabrice Bellard committed
1809
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1810 1811
        if (enc->width) {
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1812 1813
                     ", %dx%d",
                     enc->width, enc->height);
1814
            if (enc->sample_aspect_ratio.num) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1815
                av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
Luca Barbato's avatar
Luca Barbato committed
1816 1817 1818
                          enc->width * enc->sample_aspect_ratio.num,
                          enc->height * enc->sample_aspect_ratio.den,
                          1024 * 1024);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1819 1820 1821 1822
                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);
1823
            }
Luca Barbato's avatar
Luca Barbato committed
1824 1825
            if (av_log_get_level() >= AV_LOG_DEBUG) {
                int g = av_gcd(enc->time_base.num, enc->time_base.den);
1826
                snprintf(buf + strlen(buf), buf_size - strlen(buf),
Luca Barbato's avatar
Luca Barbato committed
1827 1828
                         ", %d/%d",
                         enc->time_base.num / g, enc->time_base.den / g);
1829
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1830
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1831 1832 1833 1834
        if (encode) {
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     ", q=%d-%d", enc->qmin, enc->qmax);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1835
        break;
1836
    case AVMEDIA_TYPE_AUDIO:
Fabrice Bellard's avatar
Fabrice Bellard committed
1837 1838 1839
        snprintf(buf, buf_size,
                 "Audio: %s",
                 codec_name);
1840 1841 1842
        if (profile)
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
                     " (%s)", profile);
Fabrice Bellard's avatar
Fabrice Bellard committed
1843 1844
        if (enc->sample_rate) {
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1845
                     ", %d Hz", enc->sample_rate);
Fabrice Bellard's avatar
Fabrice Bellard committed
1846
        }
1847
        av_strlcat(buf, ", ", buf_size);
1848
        av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1849
        if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1850
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1851
                     ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1852
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1853
        break;
1854
    case AVMEDIA_TYPE_DATA:
1855
        snprintf(buf, buf_size, "Data: %s", codec_name);
1856
        break;
1857
    case AVMEDIA_TYPE_SUBTITLE:
1858
        snprintf(buf, buf_size, "Subtitle: %s", codec_name);
1859
        break;
1860
    case AVMEDIA_TYPE_ATTACHMENT:
1861 1862
        snprintf(buf, buf_size, "Attachment: %s", codec_name);
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1863
    default:
1864 1865
        snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
        return;
Fabrice Bellard's avatar
Fabrice Bellard committed
1866
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1867 1868 1869 1870 1871 1872 1873 1874
    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");
    }
1875
    bitrate = get_bit_rate(enc);
Fabrice Bellard's avatar
Fabrice Bellard committed
1876
    if (bitrate != 0) {
1877
        snprintf(buf + strlen(buf), buf_size - strlen(buf),
Fabrice Bellard's avatar
Fabrice Bellard committed
1878
                 ", %d kb/s", bitrate / 1000);
Fabrice Bellard's avatar
Fabrice Bellard committed
1879 1880 1881
    }
}

1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
const char *av_get_profile_name(const AVCodec *codec, int profile)
{
    const AVProfile *p;
    if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
        return NULL;

    for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
        if (p->profile == profile)
            return p->name;

    return NULL;
}

Luca Barbato's avatar
Luca Barbato committed
1895
unsigned avcodec_version(void)
Nick Kurshev's avatar
Nick Kurshev committed
1896
{
Luca Barbato's avatar
Luca Barbato committed
1897
    return LIBAVCODEC_VERSION_INT;
Nick Kurshev's avatar
Nick Kurshev committed
1898
}
Fabrice Bellard's avatar
Fabrice Bellard committed
1899

1900
const char *avcodec_configuration(void)
1901
{
1902
    return LIBAV_CONFIGURATION;
1903 1904
}

1905
const char *avcodec_license(void)
1906 1907
{
#define LICENSE_PREFIX "libavcodec license: "
1908
    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
1909 1910
}

1911 1912
void avcodec_flush_buffers(AVCodecContext *avctx)
{
Luca Barbato's avatar
Luca Barbato committed
1913
    if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
1914
        ff_thread_flush(avctx);
Luca Barbato's avatar
Luca Barbato committed
1915
    else if (avctx->codec->flush)
Michael Niedermayer's avatar
Michael Niedermayer committed
1916
        avctx->codec->flush(avctx);
1917 1918

    if (!avctx->refcounted_frames)
1919
        av_frame_unref(avctx->internal->to_free);
1920 1921
}

1922
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
1923
{
Luca Barbato's avatar
Luca Barbato committed
1924
    switch (codec_id) {
1925 1926 1927 1928 1929 1930
    case AV_CODEC_ID_ADPCM_CT:
    case AV_CODEC_ID_ADPCM_IMA_APC:
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
    case AV_CODEC_ID_ADPCM_IMA_WS:
    case AV_CODEC_ID_ADPCM_G722:
    case AV_CODEC_ID_ADPCM_YAMAHA:
1931
        return 4;
1932 1933 1934 1935 1936
    case AV_CODEC_ID_PCM_ALAW:
    case AV_CODEC_ID_PCM_MULAW:
    case AV_CODEC_ID_PCM_S8:
    case AV_CODEC_ID_PCM_U8:
    case AV_CODEC_ID_PCM_ZORK:
1937
        return 8;
1938 1939 1940 1941 1942
    case AV_CODEC_ID_PCM_S16BE:
    case AV_CODEC_ID_PCM_S16LE:
    case AV_CODEC_ID_PCM_S16LE_PLANAR:
    case AV_CODEC_ID_PCM_U16BE:
    case AV_CODEC_ID_PCM_U16LE:
1943
        return 16;
1944 1945 1946
    case AV_CODEC_ID_PCM_S24DAUD:
    case AV_CODEC_ID_PCM_S24BE:
    case AV_CODEC_ID_PCM_S24LE:
1947
    case AV_CODEC_ID_PCM_S24LE_PLANAR:
1948 1949
    case AV_CODEC_ID_PCM_U24BE:
    case AV_CODEC_ID_PCM_U24LE:
1950
        return 24;
1951 1952
    case AV_CODEC_ID_PCM_S32BE:
    case AV_CODEC_ID_PCM_S32LE:
1953
    case AV_CODEC_ID_PCM_S32LE_PLANAR:
1954 1955 1956 1957
    case AV_CODEC_ID_PCM_U32BE:
    case AV_CODEC_ID_PCM_U32LE:
    case AV_CODEC_ID_PCM_F32BE:
    case AV_CODEC_ID_PCM_F32LE:
1958
        return 32;
1959 1960
    case AV_CODEC_ID_PCM_F64BE:
    case AV_CODEC_ID_PCM_F64LE:
1961
        return 64;
1962 1963 1964 1965 1966
    default:
        return 0;
    }
}

1967
int av_get_bits_per_sample(enum AVCodecID codec_id)
1968 1969
{
    switch (codec_id) {
1970
    case AV_CODEC_ID_ADPCM_SBPRO_2:
1971
        return 2;
1972
    case AV_CODEC_ID_ADPCM_SBPRO_3:
1973
        return 3;
1974 1975 1976 1977 1978
    case AV_CODEC_ID_ADPCM_SBPRO_4:
    case AV_CODEC_ID_ADPCM_IMA_WAV:
    case AV_CODEC_ID_ADPCM_IMA_QT:
    case AV_CODEC_ID_ADPCM_SWF:
    case AV_CODEC_ID_ADPCM_MS:
1979 1980 1981 1982 1983 1984
        return 4;
    default:
        return av_get_exact_bits_per_sample(codec_id);
    }
}

1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
{
    int id, sr, ch, ba, tag, bps;

    id  = avctx->codec_id;
    sr  = avctx->sample_rate;
    ch  = avctx->channels;
    ba  = avctx->block_align;
    tag = avctx->codec_tag;
    bps = av_get_exact_bits_per_sample(avctx->codec_id);

    /* codecs with an exact constant bits per sample */
    if (bps > 0 && ch > 0 && frame_bytes > 0)
        return (frame_bytes * 8) / (bps * ch);
    bps = avctx->bits_per_coded_sample;

    /* codecs with a fixed packet duration */
    switch (id) {
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
    case AV_CODEC_ID_ADPCM_ADX:    return   32;
    case AV_CODEC_ID_ADPCM_IMA_QT: return   64;
    case AV_CODEC_ID_ADPCM_EA_XAS: return  128;
    case AV_CODEC_ID_AMR_NB:
    case AV_CODEC_ID_GSM:
    case AV_CODEC_ID_QCELP:
    case AV_CODEC_ID_RA_144:
    case AV_CODEC_ID_RA_288:       return  160;
    case AV_CODEC_ID_IMC:          return  256;
    case AV_CODEC_ID_AMR_WB:
    case AV_CODEC_ID_GSM_MS:       return  320;
    case AV_CODEC_ID_MP1:          return  384;
    case AV_CODEC_ID_ATRAC1:       return  512;
    case AV_CODEC_ID_ATRAC3:       return 1024;
    case AV_CODEC_ID_MP2:
    case AV_CODEC_ID_MUSEPACK7:    return 1152;
    case AV_CODEC_ID_AC3:          return 1536;
2020 2021 2022 2023
    }

    if (sr > 0) {
        /* calc from sample rate */
2024
        if (id == AV_CODEC_ID_TTA)
2025 2026 2027 2028
            return 256 * sr / 245;

        if (ch > 0) {
            /* calc from sample rate and channels */
2029
            if (id == AV_CODEC_ID_BINKAUDIO_DCT)
2030 2031 2032 2033 2034 2035
                return (480 << (sr / 22050)) / ch;
        }
    }

    if (ba > 0) {
        /* calc from block_align */
2036
        if (id == AV_CODEC_ID_SIPR) {
2037 2038 2039 2040 2041 2042
            switch (ba) {
            case 20: return 160;
            case 19: return 144;
            case 29: return 288;
            case 37: return 480;
            }
2043
        } else if (id == AV_CODEC_ID_ILBC) {
2044 2045 2046 2047
            switch (ba) {
            case 38: return 160;
            case 50: return 240;
            }
2048 2049 2050 2051 2052
        }
    }

    if (frame_bytes > 0) {
        /* calc from frame_bytes only */
2053
        if (id == AV_CODEC_ID_TRUESPEECH)
2054
            return 240 * (frame_bytes / 32);
2055
        if (id == AV_CODEC_ID_NELLYMOSER)
2056 2057 2058 2059
            return 256 * (frame_bytes / 64);

        if (bps > 0) {
            /* calc from frame_bytes and bits_per_coded_sample */
2060
            if (id == AV_CODEC_ID_ADPCM_G726)
2061 2062 2063 2064 2065 2066
                return frame_bytes * 8 / bps;
        }

        if (ch > 0) {
            /* calc from frame_bytes and channels */
            switch (id) {
2067 2068
            case AV_CODEC_ID_ADPCM_4XM:
            case AV_CODEC_ID_ADPCM_IMA_ISS:
2069
                return (frame_bytes - 4 * ch) * 2 / ch;
2070
            case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
2071
                return (frame_bytes - 4) * 2 / ch;
2072
            case AV_CODEC_ID_ADPCM_IMA_AMV:
2073
                return (frame_bytes - 8) * 2 / ch;
2074
            case AV_CODEC_ID_ADPCM_XA:
2075
                return (frame_bytes / 128) * 224 / ch;
2076
            case AV_CODEC_ID_INTERPLAY_DPCM:
2077
                return (frame_bytes - 6 - ch) / ch;
2078
            case AV_CODEC_ID_ROQ_DPCM:
2079
                return (frame_bytes - 8) / ch;
2080
            case AV_CODEC_ID_XAN_DPCM:
2081
                return (frame_bytes - 2 * ch) / ch;
2082
            case AV_CODEC_ID_MACE3:
2083
                return 3 * frame_bytes / ch;
2084
            case AV_CODEC_ID_MACE6:
2085
                return 6 * frame_bytes / ch;
2086
            case AV_CODEC_ID_PCM_LXF:
2087 2088 2089 2090 2091
                return 2 * (frame_bytes / (5 * ch));
            }

            if (tag) {
                /* calc from frame_bytes, channels, and codec_tag */
2092
                if (id == AV_CODEC_ID_SOL_DPCM) {
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
                    if (tag == 3)
                        return frame_bytes / ch;
                    else
                        return frame_bytes * 2 / ch;
                }
            }

            if (ba > 0) {
                /* calc from frame_bytes, channels, and block_align */
                int blocks = frame_bytes / ba;
                switch (avctx->codec_id) {
2104
                case AV_CODEC_ID_ADPCM_IMA_WAV:
2105
                    return blocks * (1 + (ba - 4 * ch) / (4 * ch) * 8);
2106
                case AV_CODEC_ID_ADPCM_IMA_DK3:
2107
                    return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
2108
                case AV_CODEC_ID_ADPCM_IMA_DK4:
2109
                    return blocks * (1 + (ba - 4 * ch) * 2 / ch);
2110
                case AV_CODEC_ID_ADPCM_MS:
2111 2112 2113 2114 2115 2116 2117
                    return blocks * (2 + (ba - 7 * ch) * 2 / ch);
                }
            }

            if (bps > 0) {
                /* calc from frame_bytes, channels, and bits_per_coded_sample */
                switch (avctx->codec_id) {
2118
                case AV_CODEC_ID_PCM_DVD:
2119
                    return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
2120
                case AV_CODEC_ID_PCM_BLURAY:
2121
                    return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
2122
                case AV_CODEC_ID_S302M:
2123 2124 2125 2126 2127 2128 2129 2130 2131
                    return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
                }
            }
        }
    }

    return 0;
}

2132
#if !HAVE_THREADS
Luca Barbato's avatar
Luca Barbato committed
2133 2134
int ff_thread_init(AVCodecContext *s)
{
2135 2136
    return -1;
}
Luca Barbato's avatar
Luca Barbato committed
2137

2138
#endif
2139 2140 2141 2142 2143

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

Luca Barbato's avatar
Luca Barbato committed
2144
    while (v >= 0xff) {
2145 2146 2147 2148 2149 2150 2151 2152
        *s++ = 0xff;
        v -= 0xff;
        n++;
    }
    *s = v;
    n++;
    return n;
}
2153

Luca Barbato's avatar
Luca Barbato committed
2154 2155
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
{
2156
    int i;
Luca Barbato's avatar
Luca Barbato committed
2157
    for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
2158 2159 2160
    return i;
}

2161
#if FF_API_MISSING_SAMPLE
2162
FF_DISABLE_DEPRECATION_WARNINGS
2163
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
2164
{
2165
    av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your Libav "
2166
            "version to the newest one from Git. If the problem still "
2167
            "occurs, it means that your file has a feature which has not "
2168
            "been implemented.\n", feature);
2169
    if(want_sample)
2170
        av_log_ask_for_sample(avc, NULL);
2171 2172
}

2173
void av_log_ask_for_sample(void *avc, const char *msg, ...)
2174
{
2175 2176 2177 2178
    va_list argument_list;

    va_start(argument_list, msg);

2179
    if (msg)
2180
        av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
2181
    av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
2182
            "of this file to ftp://upload.libav.org/incoming/ "
2183
            "and contact the libav-devel mailing list.\n");
2184 2185

    va_end(argument_list);
2186
}
2187
FF_ENABLE_DEPRECATION_WARNINGS
2188
#endif /* FF_API_MISSING_SAMPLE */
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199

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;
}
2200 2201 2202 2203 2204

AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
{
    return hwaccel ? hwaccel->next : first_hwaccel;
}
Michael Niedermayer's avatar
Michael Niedermayer committed
2205

2206
AVHWAccel *ff_find_hwaccel(AVCodecContext *avctx)
Michael Niedermayer's avatar
Michael Niedermayer committed
2207
{
2208 2209 2210
    enum AVCodecID codec_id = avctx->codec->id;
    enum AVPixelFormat pix_fmt = avctx->pix_fmt;

Luca Barbato's avatar
Luca Barbato committed
2211
    AVHWAccel *hwaccel = NULL;
Michael Niedermayer's avatar
Michael Niedermayer committed
2212

Luca Barbato's avatar
Luca Barbato committed
2213 2214
    while ((hwaccel = av_hwaccel_next(hwaccel)))
        if (hwaccel->id == codec_id
Michael Niedermayer's avatar
Michael Niedermayer committed
2215 2216 2217 2218
            && hwaccel->pix_fmt == pix_fmt)
            return hwaccel;
    return NULL;
}
2219 2220 2221

int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
{
2222 2223
    if (lockmgr_cb) {
        if (lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY))
2224
            return -1;
2225
        if (lockmgr_cb(&avformat_mutex, AV_LOCK_DESTROY))
2226
            return -1;
2227 2228
    }

2229
    lockmgr_cb = cb;
2230

2231 2232
    if (lockmgr_cb) {
        if (lockmgr_cb(&codec_mutex, AV_LOCK_CREATE))
2233
            return -1;
2234
        if (lockmgr_cb(&avformat_mutex, AV_LOCK_CREATE))
2235 2236 2237 2238 2239 2240 2241
            return -1;
    }
    return 0;
}

int avpriv_lock_avformat(void)
{
2242 2243
    if (lockmgr_cb) {
        if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
2244 2245 2246 2247 2248 2249 2250
            return -1;
    }
    return 0;
}

int avpriv_unlock_avformat(void)
{
2251 2252
    if (lockmgr_cb) {
        if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_RELEASE))
2253
            return -1;
2254 2255 2256
    }
    return 0;
}
2257

2258
unsigned int avpriv_toupper4(unsigned int x)
2259
{
2260 2261 2262 2263
    return av_toupper(x & 0xFF) +
          (av_toupper((x >>  8) & 0xFF) << 8)  +
          (av_toupper((x >> 16) & 0xFF) << 16) +
          (av_toupper((x >> 24) & 0xFF) << 24);
2264
}
2265

2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
{
    int ret;

    dst->owner = src->owner;

    ret = av_frame_ref(dst->f, src->f);
    if (ret < 0)
        return ret;

    if (src->progress &&
        !(dst->progress = av_buffer_ref(src->progress))) {
        ff_thread_release_buffer(dst->owner, dst);
        return AVERROR(ENOMEM);
    }

    return 0;
}

2285
#if !HAVE_THREADS
2286

2287
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
2288 2289
{
    f->owner = avctx;
2290
    return ff_get_buffer(avctx, f->f, flags);
2291 2292
}

2293
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
2294
{
2295 2296
    if (f->f)
        av_frame_unref(f->f);
2297 2298 2299 2300 2301 2302
}

void ff_thread_finish_setup(AVCodecContext *avctx)
{
}

2303
void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
2304 2305 2306
{
}

2307
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
2308 2309 2310 2311
{
}

#endif
2312

2313
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
2314
{
2315
    if (codec_id <= AV_CODEC_ID_NONE)
2316
        return AVMEDIA_TYPE_UNKNOWN;
2317
    else if (codec_id < AV_CODEC_ID_FIRST_AUDIO)
2318
        return AVMEDIA_TYPE_VIDEO;
2319
    else if (codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
2320
        return AVMEDIA_TYPE_AUDIO;
2321
    else if (codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
2322 2323 2324 2325
        return AVMEDIA_TYPE_SUBTITLE;

    return AVMEDIA_TYPE_UNKNOWN;
}
2326 2327 2328 2329 2330

int avcodec_is_open(AVCodecContext *s)
{
    return !!s->internal;
}
2331

2332 2333 2334
const uint8_t *avpriv_find_start_code(const uint8_t *restrict p,
                                      const uint8_t *end,
                                      uint32_t * restrict state)
2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363
{
    int i;

    assert(p <= end);
    if (p >= end)
        return end;

    for (i = 0; i < 3; i++) {
        uint32_t tmp = *state << 8;
        *state = tmp + *(p++);
        if (tmp == 0x100 || p == end)
            return p;
    }

    while (p < end) {
        if      (p[-1] > 1      ) p += 3;
        else if (p[-2]          ) p += 2;
        else if (p[-3]|(p[-1]-1)) p++;
        else {
            p++;
            break;
        }
    }

    p = FFMIN(p, end) - 4;
    *state = AV_RB32(p);

    return p + 4;
}