PeerStreamer

    if (avctx->error_recognition >= FF_ER_CAREFUL) {

        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);

        if (!s->input_buffer)

    }

    avctx->sample_fmt = SAMPLE_FMT_S16;

        /* allocate additional 12 bytes to accomodate av_memcpy_backptr() OUTBUF_PADDED optimisation */

        s->frame.data[0] = av_malloc(s->width*s->height + 12);

        if (!s->frame.data[0])

        s->frame.data[1] = av_malloc(AVPALETTE_SIZE);

        if (!s->frame.data[1]) {

            av_freep(&s->frame.data[0]);

        }

    }

    memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);

    /* initialize MD5 context */

    s->md5ctx = av_malloc(av_md5_size);

    if(!s->md5ctx)

    av_md5_init(s->md5ctx);

    streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);

    avctx->coded_frame = &s->picture;

    s->lzw = av_mallocz(ff_lzw_encode_state_size);

    if (!s->lzw)

    s->buf = av_malloc(avctx->width*avctx->height*2);

    if (!s->buf)

    return 0;

}

    st = av_new_stream(s, 0);

    if(!st) {

        vfw_read_close(s);

    }

    /* Set video format */

    bi = av_malloc(bisize);

    if(!bi) {

        vfw_read_close(s);

    }

    ret = SendMessage(ctx->hwnd, WM_CAP_GET_VIDEOFORMAT, bisize, (LPARAM) bi);

    if(!ret)

    }

    ape->frames       = av_malloc(ape->totalframes * sizeof(APEFrame));

    if(!ape->frames)

    ape->firstframe   = ape->junklength + ape->descriptorlength + ape->headerlength + ape->seektablelength + ape->wavheaderlength;

    ape->currentframe = 0;

        nblocks = ape->blocksperframe;

    if (av_new_packet(pkt,  ape->frames[ape->currentframe].size + extra_size) < 0)

    AV_WL32(pkt->data    , nblocks);

    AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip);

        return -1;

    value = av_malloc(size+1);

    if (!value)

    get_buffer(pb, value, size);

    value[size] = 0;

    av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL);

    /* new audio stream */

    st = av_new_stream(s, 0);

    if (!st)

    /* parse format description */

    st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;

        case FLAC_METADATA_TYPE_VORBIS_COMMENT:

            buffer = av_mallocz(metadata_size + FF_INPUT_BUFFER_PADDING_SIZE);

            if (!buffer) {

            }

            if (get_buffer(s->pb, buffer, metadata_size) != metadata_size) {

                av_freep(&buffer);

            st->codec->extradata_size > 0) {

            ts_st->adts = av_mallocz(sizeof(*ts_st->adts));

            if (!ts_st->adts)

            if (ff_adts_decode_extradata(s, ts_st->adts, st->codec->extradata,

                                         st->codec->extradata_size) < 0)

                return -1;

                return -1;

            data = av_malloc(new_size);

            if (!data)

            ff_adts_write_frame_header(adts, data, pkt->size, adts->pce_size);

            if (adts->pce_size) {

                memcpy(data+ADTS_HEADER_SIZE, adts->pce_data, adts->pce_size);

    st = av_new_stream(ctx, 0);

    if(!st)

    codec = st->codec;

    codec->codec_type = AVMEDIA_TYPE_VIDEO;

    oggstream->header[0] = av_mallocz(51); // per ogg flac specs

    p = oggstream->header[0];

    if (!p)

    bytestream_put_byte(&p, 0x7F);

    bytestream_put_buffer(&p, "FLAC", 4);

    bytestream_put_byte(&p, 1); // major version

    // second packet: VorbisComment

    p = ogg_write_vorbiscomment(4, bitexact, &oggstream->header_len[1], m);

    if (!p)

    oggstream->header[1] = p;

    bytestream_put_byte(&p, 0x84); // last metadata block and vorbis comment

    bytestream_put_be24(&p, oggstream->header_len[1] - 4);

    // first packet: Speex header

    p = av_mallocz(SPEEX_HEADER_SIZE);

    if (!p)

    oggstream->header[0] = p;

    oggstream->header_len[0] = SPEEX_HEADER_SIZE;

    bytestream_put_buffer(&p, avctx->extradata, SPEEX_HEADER_SIZE);

    // second packet: VorbisComment

    p = ogg_write_vorbiscomment(0, bitexact, &oggstream->header_len[1], m);

    if (!p)

    oggstream->header[1] = p;

    return 0;

        return -1;

    avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);

    if (!avctx->extradata)

    avctx->extradata_size = get_buffer(pb, avctx->extradata, size);

    memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

    if (avctx->extradata_size != size)

    /* Everything except the codec mode request byte should be output. */

    if (av_new_packet(pkt, len - 1)) {

        av_log(ctx, AV_LOG_ERROR, "Out of memory\n");

    }

    pkt->stream_index = st->index;

    ptr = pkt->data;

    if (av_new_packet(pkt, len + startcode)) {

        av_log(ctx, AV_LOG_ERROR, "Out of memory\n");

    }

    pkt->stream_index = st->index;

    ptr = pkt->data;

        if (av_new_packet(pkt, data_len)) {

            av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");

        }

        pkt->stream_index = st->index;

            if (av_new_packet(pkt, frame_size)) {

                av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");

            }

            memcpy(pkt->data, xiph_data, frame_size);

    ptr = codec->extradata = av_malloc(extradata_alloc);

    if (!ptr) {

        av_log(codec, AV_LOG_ERROR, "Out of memory\n");

    }

    *ptr++ = 2;

    ptr += av_xiphlacing(ptr, length1);

            } else {

                av_log(codec, AV_LOG_ERROR,

                       "Out of memory while decoding SDP configuration.\n");

            }

        } else {

            av_log(codec, AV_LOG_ERROR, "Packet too large\n");

    if (!(value = av_malloc(value_size))) {

        av_log(codec, AV_LOG_ERROR, "Out of memory\n");

    }

    if (av_strstart(line, "fmtp:", &p)) {

            /* load up the name */

            buffer = av_malloc(size+1);

            if (!buffer)

            if ((ret = get_buffer(pb, buffer, size)) != size)

                return AVERROR(EIO);

            buffer[size] = 0;