コード例 #1
0
ファイル: rtpdec.c プロジェクト: 2BReality/xbmc
void ff_rtp_send_punch_packets(URLContext* rtp_handle)
{
    AVIOContext *pb;
    uint8_t *buf;
    int len;

    /* Send a small RTP packet */
    if (avio_open_dyn_buf(&pb) < 0)
        return;

    avio_w8(pb, (RTP_VERSION << 6));
    avio_w8(pb, 0); /* Payload type */
    avio_wb16(pb, 0); /* Seq */
    avio_wb32(pb, 0); /* Timestamp */
    avio_wb32(pb, 0); /* SSRC */

    avio_flush(pb);
    len = avio_close_dyn_buf(pb, &buf);
    if ((len > 0) && buf)
        ffurl_write(rtp_handle, buf, len);
    av_free(buf);

    /* Send a minimal RTCP RR */
    if (avio_open_dyn_buf(&pb) < 0)
        return;

    avio_w8(pb, (RTP_VERSION << 6));
    avio_w8(pb, RTCP_RR); /* receiver report */
    avio_wb16(pb, 1); /* length in words - 1 */
    avio_wb32(pb, 0); /* our own SSRC */

    avio_flush(pb);
    len = avio_close_dyn_buf(pb, &buf);
    if ((len > 0) && buf)
        ffurl_write(rtp_handle, buf, len);
    av_free(buf);
}
コード例 #2
0
static int mmf_write_header(AVFormatContext *s)
{
	MMFContext *mmf = s->priv_data;
	AVIOContext *pb = s->pb;
	int64_t pos;
	int rate;

	rate = mmf_rate_code(s->streams[0]->codec->sample_rate);
	if(rate < 0)
	{
		av_log(s, AV_LOG_ERROR, "Unsupported sample rate %d\n", s->streams[0]->codec->sample_rate);
		return -1;
	}

	ffio_wfourcc(pb, "MMMD");
	avio_wb32(pb, 0);
	pos = ff_start_tag(pb, "CNTI");
	avio_w8(pb, 0); /* class */
	avio_w8(pb, 0); /* type */
	avio_w8(pb, 0); /* code type */
	avio_w8(pb, 0); /* status */
	avio_w8(pb, 0); /* counts */
	avio_write(pb, "VN:libavcodec,", sizeof("VN:libavcodec,") -1); /* metadata ("ST:songtitle,VN:version,...") */
	end_tag_be(pb, pos);

	avio_write(pb, "ATR\x00", 4);
	avio_wb32(pb, 0);
	mmf->atrpos = avio_tell(pb);
	avio_w8(pb, 0); /* format type */
	avio_w8(pb, 0); /* sequence type */
	avio_w8(pb, (0 << 7) | (1 << 4) | rate); /* (channel << 7) | (format << 4) | rate */
	avio_w8(pb, 0); /* wave base bit */
	avio_w8(pb, 2); /* time base d */
	avio_w8(pb, 2); /* time base g */

	ffio_wfourcc(pb, "Atsq");
	avio_wb32(pb, 16);
	mmf->atsqpos = avio_tell(pb);
	/* Will be filled on close */
	avio_write(pb, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16);

	mmf->awapos = ff_start_tag(pb, "Awa\x01");

	av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);

	avio_flush(pb);

	return 0;
}
コード例 #3
0
ファイル: au.c プロジェクト: 10045125/xuggle-xuggler
static int au_write_header(AVFormatContext *s)
{
    AVIOContext *pb = s->pb;

    s->priv_data = NULL;

    /* format header */
    if (put_au_header(pb, s->streams[0]->codec) < 0) {
        return -1;
    }

    avio_flush(pb);

    return 0;
}
コード例 #4
0
ファイル: ffmpeg.c プロジェクト: doczii/motion
/**
 * mpeg1_write_trailer
 *      We set AVOutputFormat->write_trailer to this function for mpeg1. That way,
 *      the mpeg1 video gets a proper trailer when it is closed.
 *
 *  Returns 0
 *
 */
static int mpeg1_write_trailer(AVFormatContext *s)
{
#if defined FF_API_NEW_AVIO
    avio_write(s->pb, mpeg1_trailer, 4);
    avio_flush(s->pb);
#elif LIBAVFORMAT_BUILD >= (52<<16)
    put_buffer(s->pb, mpeg1_trailer, 4);
    put_flush_packet(s->pb);
#else
    put_buffer(&s->pb, mpeg1_trailer, 4);
    put_flush_packet(&s->pb);
#endif /* FF_API_NEW_AVIO -- LIBAVFORMAT_BUILD >= (52<<16) */

    return 0; /* success */
}
コード例 #5
0
ファイル: vc1testenc.c プロジェクト: stainberg/android_FFMPEG
static int vc1test_write_packet(AVFormatContext *s, AVPacket *pkt)
{
    RCVContext *ctx = s->priv_data;
    AVIOContext *pb = s->pb;

    if (!pkt->size)
        return 0;
    avio_wl32(pb, pkt->size | ((pkt->flags & AV_PKT_FLAG_KEY) ? 0x80000000 : 0));
    avio_wl32(pb, pkt->pts);
    avio_write(pb, pkt->data, pkt->size);
    avio_flush(pb);
    ctx->frames++;

    return 0;
}
コード例 #6
0
ファイル: wvenc.c プロジェクト: AndiDog/FFmpeg
static int write_trailer(AVFormatContext *s)
{
    WVMuxContext *wc = s->priv_data;
    AVIOContext *pb = s->pb;

    ff_ape_write(s);

    if (pb->seekable) {
        avio_seek(pb, 12, SEEK_SET);
        avio_wl32(pb, wc->duration);
        avio_flush(pb);
    }

    return 0;
}
コード例 #7
0
ファイル: md5enc.c プロジェクト: 0x0B501E7E/ffmpeg
static void md5_finish(struct AVFormatContext *s, char *buf)
{
    uint8_t md5[16];
    int i, offset = strlen(buf);
    av_md5_final(s->priv_data, md5);
    for (i = 0; i < sizeof(md5); i++) {
        snprintf(buf + offset, 3, "%02"PRIx8, md5[i]);
        offset += 2;
    }
    buf[offset] = '\n';
    buf[offset+1] = 0;

    avio_write(s->pb, buf, strlen(buf));
    avio_flush(s->pb);
}
コード例 #8
0
ファイル: rmenc.c プロジェクト: changbiao/libav
static int rm_write_header(AVFormatContext *s)
{
    RMMuxContext *rm = s->priv_data;
    StreamInfo *stream;
    int n;
    AVCodecContext *codec;

    for(n=0;n<s->nb_streams;n++) {
        AVStream *st = s->streams[n];
        int frame_size;

        s->streams[n]->id = n;
        codec = s->streams[n]->codec;
        stream = &rm->streams[n];
        memset(stream, 0, sizeof(StreamInfo));
        stream->num = n;
        stream->bit_rate = codec->bit_rate;
        stream->enc = codec;

        switch(codec->codec_type) {
        case AVMEDIA_TYPE_AUDIO:
            rm->audio_stream = stream;
            frame_size = av_get_audio_frame_duration(codec, 0);
            stream->frame_rate = (float)codec->sample_rate / (float)frame_size;
            /* XXX: dummy values */
            stream->packet_max_size = 1024;
            stream->nb_packets = 0;
            stream->total_frames = stream->nb_packets;
            break;
        case AVMEDIA_TYPE_VIDEO:
            rm->video_stream = stream;
            // TODO: should be avg_frame_rate
            stream->frame_rate = (float)st->time_base.den / (float)st->time_base.num;
            /* XXX: dummy values */
            stream->packet_max_size = 4096;
            stream->nb_packets = 0;
            stream->total_frames = stream->nb_packets;
            break;
        default:
            return -1;
        }
    }

    if (rv10_write_header(s, 0, 0))
        return AVERROR_INVALIDDATA;
    avio_flush(s->pb);
    return 0;
}
コード例 #9
0
ファイル: rmenc.c プロジェクト: 1c0n/xbmc
static int rm_write_header(AVFormatContext *s)
{
    RMMuxContext *rm = s->priv_data;
    StreamInfo *stream;
    int n;
    AVCodecContext *codec;

    if (s->nb_streams > 2) {
        av_log(s, AV_LOG_ERROR, "At most 2 streams are currently supported for muxing in RM\n");
        return AVERROR_PATCHWELCOME;
    }

    for(n=0;n<s->nb_streams;n++) {
        s->streams[n]->id = n;
        codec = s->streams[n]->codec;
        stream = &rm->streams[n];
        memset(stream, 0, sizeof(StreamInfo));
        stream->num = n;
        stream->bit_rate = codec->bit_rate;
        stream->enc = codec;

        switch(codec->codec_type) {
        case AVMEDIA_TYPE_AUDIO:
            rm->audio_stream = stream;
            stream->frame_rate = (float)codec->sample_rate / (float)codec->frame_size;
            /* XXX: dummy values */
            stream->packet_max_size = 1024;
            stream->nb_packets = 0;
            stream->total_frames = stream->nb_packets;
            break;
        case AVMEDIA_TYPE_VIDEO:
            rm->video_stream = stream;
            stream->frame_rate = (float)codec->time_base.den / (float)codec->time_base.num;
            /* XXX: dummy values */
            stream->packet_max_size = 4096;
            stream->nb_packets = 0;
            stream->total_frames = stream->nb_packets;
            break;
        default:
            return -1;
        }
    }

    if (rv10_write_header(s, 0, 0))
        return AVERROR_INVALIDDATA;
    avio_flush(s->pb);
    return 0;
}
コード例 #10
0
static int write_packet(AVFormatContext *s, AVPacket *pkt)
{
    AVIOContext *pb = s->pb;
    GetBitContext gb;
    int i;

    avio_wl16(pb, SYNC_WORD);
    avio_wl16(pb, 8 * 10);

    init_get_bits(&gb, pkt->data, 8*10);
    for(i=0; i< 8 * 10; i++)
        avio_wl16(pb, get_bits1(&gb) ? BIT_1 : BIT_0);
    avio_flush(pb);

    return 0;
}
コード例 #11
0
ファイル: wtvenc.c プロジェクト: Brhett/FFmpeg
static int write_packet(AVFormatContext *s, AVPacket *pkt)
{
    AVIOContext *pb = s->pb;
    WtvContext  *wctx = s->priv_data;

    // write timestamp chunk
    write_timestamp(s, pkt);

    write_chunk_header(s, &ff_data_guid, pkt->size, INDEX_BASE + pkt->stream_index);
    avio_write(pb, pkt->data, pkt->size);
    write_pad(pb, WTV_PAD8(pkt->size) - pkt->size);

    wctx->serial++;
    avio_flush(pb);
    return 0;
}
コード例 #12
0
ファイル: au.c プロジェクト: ebichu/dd-wrt
static int au_write_trailer(AVFormatContext *s)
{
    AVIOContext *pb = s->pb;
    int64_t file_size = avio_tell(pb);

    if (s->pb->seekable && file_size < INT32_MAX) {
        /* update file size */
        avio_seek(pb, 8, SEEK_SET);
        avio_wb32(pb, (uint32_t)(file_size - AU_HEADER_SIZE));
        avio_seek(pb, file_size, SEEK_SET);

        avio_flush(pb);
    }

    return 0;
}
コード例 #13
0
void record_segment_time(Output_Context *ptr_output_ctx){

	if(ptr_output_ctx->start_time_mark == 0){
		ptr_output_ctx->start_time_mark = 1;
		//printf("混蛋。。。、\n");
		ptr_output_ctx->prev_segment_time = av_q2d(ptr_output_ctx->video_stream->time_base) *
													(ptr_output_ctx->pkt.pts )
													- (double)ptr_output_ctx->ptr_format_ctx->start_time / AV_TIME_BASE;

		printf("ptr_output_ctx->prev_segment_time = %f \n" ,ptr_output_ctx->prev_segment_time);

	}

	ptr_output_ctx->curr_segment_time =
						av_q2d(ptr_output_ctx->video_stream->time_base) *
										(ptr_output_ctx->pkt.pts )
										- (double)ptr_output_ctx->ptr_format_ctx->start_time / AV_TIME_BASE;
	if(ptr_output_ctx->vcodec_copy_mark == 1){ //video codecContext copy
		ptr_output_ctx->sync_ipts = ptr_output_ctx->curr_segment_time;
	}

//	//time meet
	if(ptr_output_ctx->curr_segment_time - ptr_output_ctx->prev_segment_time >= ptr_output_ctx->segment_duration){
		//printf("...meet time ...\n" );
		av_write_trailer(ptr_output_ctx->ptr_format_ctx);   // close ts file and free memory
		avio_flush(ptr_output_ctx->ptr_format_ctx->pb);
		avio_close(ptr_output_ctx->ptr_format_ctx->pb);

		printf("complete the %d.ts ,and write the m3u8 file..\n" ,ptr_output_ctx->segment_no);
		write_m3u8_body( ptr_output_ctx ,ptr_output_ctx->curr_segment_time - ptr_output_ctx->prev_segment_time ,0 );
		//concat ts file name
		sprintf(&(ptr_output_ctx->ts_name[ptr_output_ctx->dir_name_len]) ,"%s-%d.ts" ,ptr_output_ctx->ts_prfix_name ,++ptr_output_ctx->segment_no);
		if (avio_open(&(ptr_output_ctx->ptr_format_ctx->pb), ptr_output_ctx->ts_name, AVIO_FLAG_WRITE) < 0) {
			fprintf(stderr, "Could not open '%s'\n", ptr_output_ctx->ts_name);
			exit(OPEN_MUX_FILE_FAIL);
		}

        // Write a new header at the start of each file
        if (avformat_write_header(ptr_output_ctx->ptr_format_ctx, NULL)) {
          fprintf(stderr, "Could not write mpegts header to first output file\n");
          exit(AVFORMAT_WRITE_HEADER_FAIL);
        }

		ptr_output_ctx->prev_segment_time = ptr_output_ctx->curr_segment_time;   //place here
	}

}
コード例 #14
0
ファイル: gxfenc.c プロジェクト: 248668342/ffmpeg-windows
static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
{
    GXFContext *gxf = s->priv_data;
    AVIOContext *pb = s->pb;
    AVStream *st = s->streams[pkt->stream_index];
    int64_t pos = avio_tell(pb);
    int padding = 0;
    int packet_start_offset = avio_tell(pb) / 1024;

    gxf_write_packet_header(pb, PKT_MEDIA);
    if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */
        padding = 4 - pkt->size % 4;
    else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
        padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
    gxf_write_media_preamble(s, pkt, pkt->size + padding);
    avio_write(pb, pkt->data, pkt->size);
    gxf_write_padding(pb, padding);

    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
    {
        if (!(gxf->flt_entries_nb % 500))
        {
            gxf->flt_entries = av_realloc(gxf->flt_entries,
                                          (gxf->flt_entries_nb + 500) * sizeof(*gxf->flt_entries));
            if (!gxf->flt_entries)
            {
                av_log(s, AV_LOG_ERROR, "could not reallocate flt entries\n");
                return -1;
            }
        }
        gxf->flt_entries[gxf->flt_entries_nb++] = packet_start_offset;
        gxf->nb_fields += 2; // count fields
    }

    updatePacketSize(pb, pos);

    gxf->packet_count++;
    if (gxf->packet_count == 100)
    {
        gxf_write_map_packet(s, 0);
        gxf->packet_count = 0;
    }

    avio_flush(pb);

    return 0;
}
コード例 #15
0
ファイル: avcodec.cpp プロジェクト: thoas/picfit
void avcodec_decoder_release(avcodec_decoder d) {
    if (d->codec) {
        avcodec_free_context(&d->codec);
    }

    if (d->container) {
        avformat_close_input(&d->container);
    }

    if (d->avio) {
        avio_flush(d->avio);
        av_free(d->avio->buffer);
        av_free(d->avio);
    }

    delete d;
}
コード例 #16
0
ファイル: srtenc.c プロジェクト: 1c0n/xbmc
static int srt_write_packet(AVFormatContext *avf, AVPacket *pkt)
{
    SRTContext *srt = avf->priv_data;
    int write_ts = avf->streams[0]->codec->codec_id != AV_CODEC_ID_SRT;

    if (write_ts) {
        int64_t s = pkt->pts, e, d = pkt->duration;
        int size, x1 = -1, y1 = -1, x2 = -1, y2 = -1;
        const uint8_t *p;

        p = av_packet_get_side_data(pkt, AV_PKT_DATA_SUBTITLE_POSITION, &size);
        if (p && size == 16) {
            x1 = AV_RL32(p     );
            y1 = AV_RL32(p +  4);
            x2 = AV_RL32(p +  8);
            y2 = AV_RL32(p + 12);
        }

        if (d <= 0)
            /* For backward compatibility, fallback to convergence_duration. */
            d = pkt->convergence_duration;
        if (s == AV_NOPTS_VALUE || d < 0) {
            av_log(avf, AV_LOG_WARNING,
                   "Insufficient timestamps in event number %d.\n", srt->index);
            return 0;
        }
        e = s + d;
        avio_printf(avf->pb, "%d\n%02d:%02d:%02d,%03d --> %02d:%02d:%02d,%03d",
                       srt->index,
                       (int)(s / 3600000),      (int)(s / 60000) % 60,
                       (int)(s /    1000) % 60, (int)(s %  1000),
                       (int)(e / 3600000),      (int)(e / 60000) % 60,
                       (int)(e /    1000) % 60, (int)(e %  1000));
        if (p)
            avio_printf(avf->pb, "  X1:%03d X2:%03d Y1:%03d Y2:%03d",
                        x1, x2, y1, y2);
        avio_printf(avf->pb, "\n");
    }
    avio_write(avf->pb, pkt->data, pkt->size);
    if (write_ts)
        avio_write(avf->pb, "\n\n", 2);
    avio_flush(avf->pb);
    srt->index++;
    return 0;
}
コード例 #17
0
ファイル: icoenc.c プロジェクト: NullEmpty/rk_ffmpeg_android
static int ico_write_packet(AVFormatContext *s, AVPacket *pkt)
{
    IcoMuxContext *ico = s->priv_data;
    IcoImage *image;
    AVIOContext *pb = s->pb;
    AVCodecContext *c = s->streams[pkt->stream_index]->codec;
    int i;

    if (ico->current_image >= ico->nb_images) {
        av_log(s, AV_LOG_ERROR, "ICO already contains %d images\n", ico->current_image);
        return AVERROR(EIO);
    }

    image = &ico->images[ico->current_image++];

    image->offset = avio_tell(pb);
    image->width = (c->width == 256) ? 0 : c->width;
    image->height = (c->height == 256) ? 0 : c->height;

    if (c->codec_id == CODEC_ID_PNG) {
        image->bits = c->bits_per_coded_sample;
        image->size = pkt->size;

        avio_write(pb, pkt->data, pkt->size);
    } else { // BMP
        if (AV_RL32(pkt->data + 14) != 40) { // must be BITMAPINFOHEADER
            av_log(s, AV_LOG_ERROR, "Invalid BMP\n");
            return AVERROR(EINVAL);
        }

        image->bits = AV_RL16(pkt->data + 28); // allows things like 1bit and 4bit images to be preserved
        image->size = pkt->size - 14 + c->height * (c->width + 7) / 8;

        avio_write(pb, pkt->data + 14, 8); // Skip the BITMAPFILEHEADER header
        avio_wl32(pb, AV_RL32(pkt->data + 22) * 2); // rewrite height as 2 * height
        avio_write(pb, pkt->data + 26, pkt->size - 26);

        for (i = 0; i < c->height * (c->width + 7) / 8; ++i)
            avio_w8(pb, 0x00); // Write bitmask (opaque)
    }

    avio_flush(pb);

    return 0;
}
コード例 #18
0
ファイル: au.c プロジェクト: 10045125/xuggle-xuggler
static int au_write_trailer(AVFormatContext *s)
{
    AVIOContext *pb = s->pb;
    int64_t file_size;

    if (s->pb->seekable) {

        /* update file size */
        file_size = avio_tell(pb);
        avio_seek(pb, 8, SEEK_SET);
        avio_wb32(pb, (uint32_t)(file_size - 24));
        avio_seek(pb, file_size, SEEK_SET);

        avio_flush(pb);
    }

    return 0;
}
コード例 #19
0
ファイル: smjpegenc.c プロジェクト: Brhett/FFmpeg
static int smjpeg_write_trailer(AVFormatContext *s)
{
    SMJPEGMuxContext *smc = s->priv_data;
    AVIOContext *pb = s->pb;
    int64_t currentpos;

    if (pb->seekable) {
        currentpos = avio_tell(pb);
        avio_seek(pb, 12, SEEK_SET);
        avio_wb32(pb, smc->duration);
        avio_seek(pb, currentpos, SEEK_SET);
    }

    avio_wl32(pb, SMJPEG_DONE);
    avio_flush(pb);

    return 0;
}
コード例 #20
0
ファイル: hashenc.c プロジェクト: Ilste/FFmpeg
static void hash_finish(struct AVFormatContext *s, char *buf)
{
    struct HashContext *c = s->priv_data;
    uint8_t hash[AV_HASH_MAX_SIZE];
    int i, offset = strlen(buf);
    int len = av_hash_get_size(c->hash);
    av_assert0(len > 0 && len <= sizeof(hash));
    av_hash_final(c->hash, hash);
    for (i = 0; i < len; i++) {
        snprintf(buf + offset, 3, "%02"PRIx8, hash[i]);
        offset += 2;
    }
    buf[offset] = '\n';
    buf[offset+1] = 0;

    avio_write(s->pb, buf, strlen(buf));
    avio_flush(s->pb);
}
コード例 #21
0
ファイル: rtpenc.c プロジェクト: 0day-ci/FFmpeg
/* send an rtcp sender report packet */
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
{
    RTPMuxContext *s = s1->priv_data;
    uint32_t rtp_ts;

    av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);

    s->last_rtcp_ntp_time = ntp_time;
    rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
                          s1->streams[0]->time_base) + s->base_timestamp;
    avio_w8(s1->pb, RTP_VERSION << 6);
    avio_w8(s1->pb, RTCP_SR);
    avio_wb16(s1->pb, 6); /* length in words - 1 */
    avio_wb32(s1->pb, s->ssrc);
    avio_wb32(s1->pb, ntp_time / 1000000);
    avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
    avio_wb32(s1->pb, rtp_ts);
    avio_wb32(s1->pb, s->packet_count);
    avio_wb32(s1->pb, s->octet_count);

    if (s->cname) {
        int len = FFMIN(strlen(s->cname), 255);
        avio_w8(s1->pb, (RTP_VERSION << 6) + 1);
        avio_w8(s1->pb, RTCP_SDES);
        avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */

        avio_wb32(s1->pb, s->ssrc);
        avio_w8(s1->pb, 0x01); /* CNAME */
        avio_w8(s1->pb, len);
        avio_write(s1->pb, s->cname, len);
        avio_w8(s1->pb, 0); /* END */
        for (len = (7 + len) % 4; len % 4; len++)
            avio_w8(s1->pb, 0);
    }

    if (bye) {
        avio_w8(s1->pb, (RTP_VERSION << 6) | 1);
        avio_w8(s1->pb, RTCP_BYE);
        avio_wb16(s1->pb, 1); /* length in words - 1 */
        avio_wb32(s1->pb, s->ssrc);
    }

    avio_flush(s1->pb);
}
コード例 #22
0
ファイル: rmenc.c プロジェクト: 1c0n/xbmc
static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags)
{
    RMMuxContext *rm = s->priv_data;
    AVIOContext *pb = s->pb;
    StreamInfo *stream = rm->video_stream;
    int key_frame = !!(flags & AV_PKT_FLAG_KEY);

    /* XXX: this is incorrect: should be a parameter */

    /* Well, I spent some time finding the meaning of these bits. I am
       not sure I understood everything, but it works !! */
#if 1
    write_packet_header(s, stream, size + 7 + (size >= 0x4000)*4, key_frame);
    /* bit 7: '1' if final packet of a frame converted in several packets */
    avio_w8(pb, 0x81);
    /* bit 7: '1' if I frame. bits 6..0 : sequence number in current
       frame starting from 1 */
    if (key_frame) {
        avio_w8(pb, 0x81);
    } else {
        avio_w8(pb, 0x01);
    }
    if(size >= 0x4000){
        avio_wb32(pb, size); /* total frame size */
        avio_wb32(pb, size); /* offset from the start or the end */
    }else{
        avio_wb16(pb, 0x4000 | size); /* total frame size */
        avio_wb16(pb, 0x4000 | size); /* offset from the start or the end */
    }
#else
    /* full frame */
    write_packet_header(s, size + 6);
    avio_w8(pb, 0xc0);
    avio_wb16(pb, 0x4000 + size); /* total frame size */
    avio_wb16(pb, 0x4000 + packet_number * 126); /* position in stream */
#endif
    avio_w8(pb, stream->nb_frames & 0xff);

    avio_write(pb, buf, size);
    avio_flush(pb);

    stream->nb_frames++;
    return 0;
}
コード例 #23
0
ファイル: soxenc.c プロジェクト: Brhett/FFmpeg
static int sox_write_header(AVFormatContext *s)
{
    SoXContext *sox = s->priv_data;
    AVIOContext *pb = s->pb;
    AVCodecContext *enc = s->streams[0]->codec;
    AVDictionaryEntry *comment;
    size_t comment_len = 0, comment_size;

    comment = av_dict_get(s->metadata, "comment", NULL, 0);
    if (comment)
        comment_len = strlen(comment->value);
    comment_size = (comment_len + 7) & ~7;

    sox->header_size = SOX_FIXED_HDR + comment_size;

    if (enc->codec_id == AV_CODEC_ID_PCM_S32LE) {
        ffio_wfourcc(pb, ".SoX");
        avio_wl32(pb, sox->header_size);
        avio_wl64(pb, 0); /* number of samples */
        avio_wl64(pb, av_double2int(enc->sample_rate));
        avio_wl32(pb, enc->channels);
        avio_wl32(pb, comment_size);
    } else if (enc->codec_id == AV_CODEC_ID_PCM_S32BE) {
        ffio_wfourcc(pb, "XoS.");
        avio_wb32(pb, sox->header_size);
        avio_wb64(pb, 0); /* number of samples */
        avio_wb64(pb, av_double2int(enc->sample_rate));
        avio_wb32(pb, enc->channels);
        avio_wb32(pb, comment_size);
    } else {
        av_log(s, AV_LOG_ERROR, "invalid codec; use pcm_s32le or pcm_s32be\n");
        return -1;
    }

    if (comment_len)
        avio_write(pb, comment->value, comment_len);

    for ( ; comment_size > comment_len; comment_len++)
        avio_w8(pb, 0);

    avio_flush(pb);

    return 0;
}
コード例 #24
0
ファイル: aviobuf.c プロジェクト: jskew/FFmpeg
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
{
    if (s->direct && !s->update_checksum) {
        avio_flush(s);
        writeout(s, buf, size);
        return;
    }
    while (size > 0) {
        int len = FFMIN(s->buf_end - s->buf_ptr, size);
        memcpy(s->buf_ptr, buf, len);
        s->buf_ptr += len;

        if (s->buf_ptr >= s->buf_end)
            flush_buffer(s);

        buf += len;
        size -= len;
    }
}
コード例 #25
0
	void Close()
	{
		if(ctx){
			avio_flush(ctx);

			// TODO leaking memory, but if it's enabled ffmpeg crashes.
			// av_freep(&buffer);

			av_free(ctx);

			ctx = NULL;
			buffer = NULL;
		}
		
		if(f){
			fclose(f);
			f = NULL;
		}
	}
コード例 #26
0
ファイル: soxenc.c プロジェクト: Brhett/FFmpeg
static int sox_write_trailer(AVFormatContext *s)
{
    SoXContext *sox = s->priv_data;
    AVIOContext *pb = s->pb;
    AVCodecContext *enc = s->streams[0]->codec;

    if (s->pb->seekable) {
        /* update number of samples */
        int64_t file_size = avio_tell(pb);
        int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL;
        avio_seek(pb, 8, SEEK_SET);
        if (enc->codec_id == AV_CODEC_ID_PCM_S32LE) {
            avio_wl64(pb, num_samples);
        } else
            avio_wb64(pb, num_samples);
        avio_seek(pb, file_size, SEEK_SET);

        avio_flush(pb);
    }
コード例 #27
0
static int microdvd_write_header(struct AVFormatContext *s)
{
    AVCodecContext *avctx = s->streams[0]->codec;
    AVRational tb = avctx->time_base;

    if (s->nb_streams != 1 || avctx->codec_id != AV_CODEC_ID_MICRODVD) {
        av_log(s, AV_LOG_ERROR, "Exactly one MicroDVD stream is needed.\n");
        return -1;
    }

    if (avctx->extradata && avctx->extradata_size > 0) {
        avio_write(s->pb, "{DEFAULT}{}", 11);
        avio_write(s->pb, avctx->extradata, avctx->extradata_size);
        avio_flush(s->pb);
    }

    avpriv_set_pts_info(s->streams[0], 64, tb.num, tb.den);
    return 0;
}
コード例 #28
0
ファイル: wavenc.c プロジェクト: stinger151/mythtv
static int wav_write_header(AVFormatContext *s)
{
    WAVMuxContext *wav = s->priv_data;
    AVIOContext *pb = s->pb;
    int64_t fmt;

    ffio_wfourcc(pb, "RIFF");
    avio_wl32(pb, 0); /* file length */
    ffio_wfourcc(pb, "WAVE");

    /* format header */
    fmt = ff_start_tag(pb, "fmt ");
    if (ff_put_wav_header(pb, s->streams[0]->codec) < 0) {
        av_log(s, AV_LOG_ERROR, "%s codec not supported in WAVE format\n",
               s->streams[0]->codec->codec ? s->streams[0]->codec->codec->name : "NONE");
        return -1;
    }
    ff_end_tag(pb, fmt);

    if (s->streams[0]->codec->codec_tag != 0x01 /* hence for all other than PCM */
            && s->pb->seekable) {
        wav->fact_pos = ff_start_tag(pb, "fact");
        avio_wl32(pb, 0);
        ff_end_tag(pb, wav->fact_pos);
    }

    if (wav->write_bext)
        bwf_write_bext_chunk(s);

    avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
    wav->maxpts = wav->last_duration = 0;
    wav->minpts = INT64_MAX;

    /* info header */
    ff_riff_write_info(s);

    /* data header */
    wav->data = ff_start_tag(pb, "data");

    avio_flush(pb);

    return 0;
}
コード例 #29
0
ファイル: wavenc.c プロジェクト: stinger151/mythtv
static int w64_write_trailer(AVFormatContext *s)
{
    AVIOContext    *pb = s->pb;
    WAVMuxContext *wav = s->priv_data;
    int64_t file_size;

    if (pb->seekable) {
        end_guid(pb, wav->data);

        file_size = avio_tell(pb);
        avio_seek(pb, 16, SEEK_SET);
        avio_wl64(pb, file_size);
        avio_seek(pb, file_size, SEEK_SET);

        avio_flush(pb);
    }

    return 0;
}
コード例 #30
0
ファイル: filmstripenc.c プロジェクト: 0x0B501E7E/ffmpeg
static int write_trailer(AVFormatContext *s)
{
    FilmstripMuxContext *film = s->priv_data;
    AVIOContext *pb = s->pb;
    AVStream *st = s->streams[0];
    int i;

    avio_wb32(pb, RAND_TAG);
    avio_wb32(pb, film->nb_frames);
    avio_wb16(pb, 0);  // packing method
    avio_wb16(pb, 0);  // reserved
    avio_wb16(pb, st->codec->width);
    avio_wb16(pb, st->codec->height);
    avio_wb16(pb, 0);  // leading
    avio_wb16(pb, 1/av_q2d(st->codec->time_base));
    for (i = 0; i < 16; i++)
        avio_w8(pb, 0x00);  // reserved
    avio_flush(pb);
    return 0;
}