X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Fnutenc.c;h=86c98bc86a71b270c6f4d98955dda56bcaadfc6d;hb=9c9c21eaa1f0adf1c5cd17f9b31a18b979bffe37;hp=ae1bbb59a8ae5d55a838edd74710966a046b127a;hpb=7ce6892373c812e9fff7af2f8107e6ee3d0567b0;p=ffmpeg diff --git a/libavformat/nutenc.c b/libavformat/nutenc.c index ae1bbb59a8a..86c98bc86a7 100644 --- a/libavformat/nutenc.c +++ b/libavformat/nutenc.c @@ -2,26 +2,31 @@ * nut muxer * Copyright (c) 2004-2007 Michael Niedermayer * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * Libav is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * FFmpeg is distributed in the hope that it will be useful, + * Libav is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with FFmpeg; if not, write to the Free Software + * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "libavutil/intreadwrite.h" +#include "libavutil/mathematics.h" +#include "libavutil/tree.h" +#include "libavutil/dict.h" +#include "libavcodec/mpegaudiodata.h" #include "nut.h" -#include "tree.h" -#include "mpegaudiodata.h" +#include "internal.h" +#include "avio_internal.h" static int find_expected_header(AVCodecContext *c, int size, int key_frame, uint8_t out[64]){ int sample_rate= c->sample_rate; @@ -54,10 +59,10 @@ static int find_expected_header(AVCodecContext *c, int size, int key_frame, uint else if(sample_rate < (44100 + 48000)/2) sample_rate_index=0; else sample_rate_index=1; - sample_rate= ff_mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25); + sample_rate= avpriv_mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25); for(bitrate_index=2; bitrate_index<30; bitrate_index++){ - frame_size = ff_mpa_bitrate_tab[lsf][layer-1][bitrate_index>>1]; + frame_size = avpriv_mpa_bitrate_tab[lsf][layer-1][bitrate_index>>1]; frame_size = (frame_size * 144000) / (sample_rate << lsf) + (bitrate_index&1); if(frame_size == size) @@ -108,7 +113,7 @@ static void build_elision_headers(AVFormatContext *s){ int i; //FIXME this is lame //FIXME write a 2pass mode to find the maximal headers - const static uint8_t headers[][5]={ + static const uint8_t headers[][5]={ {3, 0x00, 0x00, 0x01}, {4, 0x00, 0x00, 0x01, 0xB6}, {2, 0xFF, 0xFA}, //mp3+crc @@ -151,7 +156,7 @@ static void build_frame_code(AVFormatContext *s){ int start2= start + (end-start)*stream_id / s->nb_streams; int end2 = start + (end-start)*(stream_id+1) / s->nb_streams; AVCodecContext *codec = s->streams[stream_id]->codec; - int is_audio= codec->codec_type == CODEC_TYPE_AUDIO; + int is_audio= codec->codec_type == AVMEDIA_TYPE_AUDIO; int intra_only= /*codec->intra_only || */is_audio; int pred_count; @@ -172,7 +177,6 @@ static void build_frame_code(AVFormatContext *s){ } key_frame= intra_only; -#if 1 if(is_audio){ int frame_bytes= codec->frame_size*(int64_t)codec->bit_rate / (8*codec->sample_rate); int pts; @@ -196,7 +200,6 @@ static void build_frame_code(AVFormatContext *s){ ft->pts_delta=1; start2++; } -#endif if(codec->has_b_frames){ pred_count=5; @@ -239,97 +242,76 @@ static void build_frame_code(AVFormatContext *s){ nut->frame_code['N'].flags= FLAG_INVALID; } -/** - * Gets the length in bytes which is needed to store val as v. - */ -static int get_length(uint64_t val){ - int i=1; - - while(val>>=7) - i++; - - return i; -} - -static void put_v(ByteIOContext *bc, uint64_t val){ - int i= get_length(val); - - while(--i>0) - put_byte(bc, 128 | (val>>(7*i))); - - put_byte(bc, val&127); -} - -static void put_t(NUTContext *nut, StreamContext *nus, ByteIOContext *bc, uint64_t val){ +static void put_tt(NUTContext *nut, AVRational *time_base, AVIOContext *bc, uint64_t val){ val *= nut->time_base_count; - val += nus->time_base - nut->time_base; - put_v(bc, val); + val += time_base - nut->time_base; + ff_put_v(bc, val); } /** - * Stores a string as vb. + * Store a string as vb. */ -static void put_str(ByteIOContext *bc, const char *string){ +static void put_str(AVIOContext *bc, const char *string){ int len= strlen(string); - put_v(bc, len); - put_buffer(bc, string, len); + ff_put_v(bc, len); + avio_write(bc, string, len); } -static void put_s(ByteIOContext *bc, int64_t val){ - put_v(bc, 2*FFABS(val) - (val>0)); +static void put_s(AVIOContext *bc, int64_t val){ + ff_put_v(bc, 2*FFABS(val) - (val>0)); } #ifdef TRACE -static inline void put_v_trace(ByteIOContext *bc, uint64_t v, char *file, char *func, int line){ - av_log(NULL, AV_LOG_DEBUG, "put_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line); +static inline void ff_put_v_trace(AVIOContext *bc, uint64_t v, char *file, char *func, int line){ + av_log(NULL, AV_LOG_DEBUG, "ff_put_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line); - put_v(bc, v); + ff_put_v(bc, v); } -static inline void put_s_trace(ByteIOContext *bc, int64_t v, char *file, char *func, int line){ +static inline void put_s_trace(AVIOContext *bc, int64_t v, char *file, char *func, int line){ av_log(NULL, AV_LOG_DEBUG, "put_s %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line); put_s(bc, v); } -#define put_v(bc, v) put_v_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__) +#define ff_put_v(bc, v) ff_put_v_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__) #define put_s(bc, v) put_s_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__) #endif //FIXME remove calculate_checksum -static void put_packet(NUTContext *nut, ByteIOContext *bc, ByteIOContext *dyn_bc, int calculate_checksum, uint64_t startcode){ +static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc, int calculate_checksum, uint64_t startcode){ uint8_t *dyn_buf=NULL; - int dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf); + int dyn_size= avio_close_dyn_buf(dyn_bc, &dyn_buf); int forw_ptr= dyn_size + 4*calculate_checksum; if(forw_ptr > 4096) - init_checksum(bc, ff_crc04C11DB7_update, 0); - put_be64(bc, startcode); - put_v(bc, forw_ptr); + ffio_init_checksum(bc, ff_crc04C11DB7_update, 0); + avio_wb64(bc, startcode); + ff_put_v(bc, forw_ptr); if(forw_ptr > 4096) - put_le32(bc, get_checksum(bc)); + avio_wl32(bc, ffio_get_checksum(bc)); if(calculate_checksum) - init_checksum(bc, ff_crc04C11DB7_update, 0); - put_buffer(bc, dyn_buf, dyn_size); + ffio_init_checksum(bc, ff_crc04C11DB7_update, 0); + avio_write(bc, dyn_buf, dyn_size); if(calculate_checksum) - put_le32(bc, get_checksum(bc)); + avio_wl32(bc, ffio_get_checksum(bc)); av_free(dyn_buf); } -static void write_mainheader(NUTContext *nut, ByteIOContext *bc){ +static void write_mainheader(NUTContext *nut, AVIOContext *bc){ int i, j, tmp_pts, tmp_flags, tmp_stream, tmp_mul, tmp_size, tmp_fields, tmp_head_idx; int64_t tmp_match; - put_v(bc, 3); /* version */ - put_v(bc, nut->avf->nb_streams); - put_v(bc, nut->max_distance); - put_v(bc, nut->time_base_count); + ff_put_v(bc, 3); /* version */ + ff_put_v(bc, nut->avf->nb_streams); + ff_put_v(bc, nut->max_distance); + ff_put_v(bc, nut->time_base_count); for(i=0; itime_base_count; i++){ - put_v(bc, nut->time_base[i].num); - put_v(bc, nut->time_base[i].den); + ff_put_v(bc, nut->time_base[i].num); + ff_put_v(bc, nut->time_base[i].den); } tmp_pts=0; @@ -371,65 +353,69 @@ static void write_mainheader(NUTContext *nut, ByteIOContext *bc){ } if(j != tmp_mul - tmp_size) tmp_fields=6; - put_v(bc, tmp_flags); - put_v(bc, tmp_fields); + ff_put_v(bc, tmp_flags); + ff_put_v(bc, tmp_fields); if(tmp_fields>0) put_s(bc, tmp_pts); - if(tmp_fields>1) put_v(bc, tmp_mul); - if(tmp_fields>2) put_v(bc, tmp_stream); - if(tmp_fields>3) put_v(bc, tmp_size); - if(tmp_fields>4) put_v(bc, 0 /*tmp_res*/); - if(tmp_fields>5) put_v(bc, j); - if(tmp_fields>6) put_v(bc, tmp_match); - if(tmp_fields>7) put_v(bc, tmp_head_idx); + if(tmp_fields>1) ff_put_v(bc, tmp_mul); + if(tmp_fields>2) ff_put_v(bc, tmp_stream); + if(tmp_fields>3) ff_put_v(bc, tmp_size); + if(tmp_fields>4) ff_put_v(bc, 0 /*tmp_res*/); + if(tmp_fields>5) ff_put_v(bc, j); + if(tmp_fields>6) ff_put_v(bc, tmp_match); + if(tmp_fields>7) ff_put_v(bc, tmp_head_idx); } - put_v(bc, nut->header_count-1); + ff_put_v(bc, nut->header_count-1); for(i=1; iheader_count; i++){ - put_v(bc, nut->header_len[i]); - put_buffer(bc, nut->header[i], nut->header_len[i]); + ff_put_v(bc, nut->header_len[i]); + avio_write(bc, nut->header[i], nut->header_len[i]); } } -static int write_streamheader(NUTContext *nut, ByteIOContext *bc, AVCodecContext *codec, int i){ - put_v(bc, i); +static int write_streamheader(AVFormatContext *avctx, AVIOContext *bc, AVStream *st, int i){ + NUTContext *nut = avctx->priv_data; + AVCodecContext *codec = st->codec; + ff_put_v(bc, i); switch(codec->codec_type){ - case CODEC_TYPE_VIDEO: put_v(bc, 0); break; - case CODEC_TYPE_AUDIO: put_v(bc, 1); break; - case CODEC_TYPE_SUBTITLE: put_v(bc, 2); break; - default : put_v(bc, 3); break; + case AVMEDIA_TYPE_VIDEO: ff_put_v(bc, 0); break; + case AVMEDIA_TYPE_AUDIO: ff_put_v(bc, 1); break; + case AVMEDIA_TYPE_SUBTITLE: ff_put_v(bc, 2); break; + default : ff_put_v(bc, 3); break; } - put_v(bc, 4); + ff_put_v(bc, 4); if (codec->codec_tag){ - put_le32(bc, codec->codec_tag); - }else - return -1; + avio_wl32(bc, codec->codec_tag); + } else { + av_log(avctx, AV_LOG_ERROR, "No codec tag defined for stream %d\n", i); + return AVERROR(EINVAL); + } - put_v(bc, nut->stream[i].time_base - nut->time_base); - put_v(bc, nut->stream[i].msb_pts_shift); - put_v(bc, nut->stream[i].max_pts_distance); - put_v(bc, codec->has_b_frames); - put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */ + ff_put_v(bc, nut->stream[i].time_base - nut->time_base); + ff_put_v(bc, nut->stream[i].msb_pts_shift); + ff_put_v(bc, nut->stream[i].max_pts_distance); + ff_put_v(bc, codec->has_b_frames); + avio_w8(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */ - put_v(bc, codec->extradata_size); - put_buffer(bc, codec->extradata, codec->extradata_size); + ff_put_v(bc, codec->extradata_size); + avio_write(bc, codec->extradata, codec->extradata_size); switch(codec->codec_type){ - case CODEC_TYPE_AUDIO: - put_v(bc, codec->sample_rate); - put_v(bc, 1); - put_v(bc, codec->channels); + case AVMEDIA_TYPE_AUDIO: + ff_put_v(bc, codec->sample_rate); + ff_put_v(bc, 1); + ff_put_v(bc, codec->channels); break; - case CODEC_TYPE_VIDEO: - put_v(bc, codec->width); - put_v(bc, codec->height); + case AVMEDIA_TYPE_VIDEO: + ff_put_v(bc, codec->width); + ff_put_v(bc, codec->height); - if(codec->sample_aspect_ratio.num<=0 || codec->sample_aspect_ratio.den<=0){ - put_v(bc, 0); - put_v(bc, 0); + if(st->sample_aspect_ratio.num<=0 || st->sample_aspect_ratio.den<=0){ + ff_put_v(bc, 0); + ff_put_v(bc, 0); }else{ - put_v(bc, codec->sample_aspect_ratio.num); - put_v(bc, codec->sample_aspect_ratio.den); + ff_put_v(bc, st->sample_aspect_ratio.num); + ff_put_v(bc, st->sample_aspect_ratio.den); } - put_v(bc, 0); /* csp type -- unknown */ + ff_put_v(bc, 0); /* csp type -- unknown */ break; default: break; @@ -437,48 +423,46 @@ static int write_streamheader(NUTContext *nut, ByteIOContext *bc, AVCodecContext return 0; } -static int add_info(ByteIOContext *bc, const char *type, const char *value){ +static int add_info(AVIOContext *bc, const char *type, const char *value){ put_str(bc, type); put_s(bc, -1); put_str(bc, value); return 1; } -static int write_globalinfo(NUTContext *nut, ByteIOContext *bc){ +static int write_globalinfo(NUTContext *nut, AVIOContext *bc){ AVFormatContext *s= nut->avf; - ByteIOContext *dyn_bc; + AVDictionaryEntry *t = NULL; + AVIOContext *dyn_bc; uint8_t *dyn_buf=NULL; int count=0, dyn_size; - int ret = url_open_dyn_buf(&dyn_bc); + int ret = avio_open_dyn_buf(&dyn_bc); if(ret < 0) return ret; - if(s->title [0]) count+= add_info(dyn_bc, "Title" , s->title); - if(s->author [0]) count+= add_info(dyn_bc, "Author" , s->author); - if(s->copyright[0]) count+= add_info(dyn_bc, "Copyright", s->copyright); - if(!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) - count+= add_info(dyn_bc, "Encoder" , LIBAVFORMAT_IDENT); + while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) + count += add_info(dyn_bc, t->key, t->value); - put_v(bc, 0); //stream_if_plus1 - put_v(bc, 0); //chapter_id - put_v(bc, 0); //timestamp_start - put_v(bc, 0); //length + ff_put_v(bc, 0); //stream_if_plus1 + ff_put_v(bc, 0); //chapter_id + ff_put_v(bc, 0); //timestamp_start + ff_put_v(bc, 0); //length - put_v(bc, count); + ff_put_v(bc, count); - dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf); - put_buffer(bc, dyn_buf, dyn_size); + dyn_size= avio_close_dyn_buf(dyn_bc, &dyn_buf); + avio_write(bc, dyn_buf, dyn_size); av_free(dyn_buf); return 0; } -static int write_streaminfo(NUTContext *nut, ByteIOContext *bc, int stream_id){ +static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){ AVFormatContext *s= nut->avf; AVStream* st = s->streams[stream_id]; - ByteIOContext *dyn_bc; + AVIOContext *dyn_bc; uint8_t *dyn_buf=NULL; int count=0, dyn_size, i; - int ret = url_open_dyn_buf(&dyn_bc); + int ret = avio_open_dyn_buf(&dyn_bc); if(ret < 0) return ret; @@ -486,51 +470,81 @@ static int write_streaminfo(NUTContext *nut, ByteIOContext *bc, int stream_id){ if (st->disposition & ff_nut_dispositions[i].flag) count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str); } - dyn_size = url_close_dyn_buf(dyn_bc, &dyn_buf); + dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf); if (count) { - put_v(bc, stream_id + 1); //stream_id_plus1 - put_v(bc, 0); //chapter_id - put_v(bc, 0); //timestamp_start - put_v(bc, 0); //length + ff_put_v(bc, stream_id + 1); //stream_id_plus1 + ff_put_v(bc, 0); //chapter_id + ff_put_v(bc, 0); //timestamp_start + ff_put_v(bc, 0); //length - put_v(bc, count); + ff_put_v(bc, count); - put_buffer(bc, dyn_buf, dyn_size); + avio_write(bc, dyn_buf, dyn_size); } av_free(dyn_buf); return count; } -static int write_headers(NUTContext *nut, ByteIOContext *bc){ - ByteIOContext *dyn_bc; +static int write_chapter(NUTContext *nut, AVIOContext *bc, int id) +{ + AVIOContext *dyn_bc; + uint8_t *dyn_buf = NULL; + AVDictionaryEntry *t = NULL; + AVChapter *ch = nut->avf->chapters[id]; + int ret, dyn_size, count = 0; + + ret = avio_open_dyn_buf(&dyn_bc); + if (ret < 0) + return ret; + + ff_put_v(bc, 0); // stream_id_plus1 + put_s(bc, id + 1); // chapter_id + put_tt(nut, nut->chapter[id].time_base, bc, ch->start); // chapter_start + ff_put_v(bc, ch->end - ch->start); // chapter_len + + while ((t = av_dict_get(ch->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) + count += add_info(dyn_bc, t->key, t->value); + + ff_put_v(bc, count); + + dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf); + avio_write(bc, dyn_buf, dyn_size); + av_freep(&dyn_buf); + return 0; +} + +static int write_headers(AVFormatContext *avctx, AVIOContext *bc){ + NUTContext *nut = avctx->priv_data; + AVIOContext *dyn_bc; int i, ret; - ret = url_open_dyn_buf(&dyn_bc); + ff_metadata_conv_ctx(avctx, ff_nut_metadata_conv, NULL); + + ret = avio_open_dyn_buf(&dyn_bc); if(ret < 0) return ret; write_mainheader(nut, dyn_bc); put_packet(nut, bc, dyn_bc, 1, MAIN_STARTCODE); for (i=0; i < nut->avf->nb_streams; i++){ - AVCodecContext *codec = nut->avf->streams[i]->codec; - - ret = url_open_dyn_buf(&dyn_bc); + ret = avio_open_dyn_buf(&dyn_bc); if(ret < 0) return ret; - write_streamheader(nut, dyn_bc, codec, i); + if ((ret = write_streamheader(avctx, dyn_bc, nut->avf->streams[i], i)) < 0) + return ret; put_packet(nut, bc, dyn_bc, 1, STREAM_STARTCODE); } - ret = url_open_dyn_buf(&dyn_bc); + ret = avio_open_dyn_buf(&dyn_bc); if(ret < 0) return ret; write_globalinfo(nut, dyn_bc); put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE); for (i = 0; i < nut->avf->nb_streams; i++) { - ret = url_open_dyn_buf(&dyn_bc); + ret = avio_open_dyn_buf(&dyn_bc); if(ret < 0) return ret; ret = write_streaminfo(nut, dyn_bc, i); @@ -540,25 +554,48 @@ static int write_headers(NUTContext *nut, ByteIOContext *bc){ put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE); else { uint8_t* buf; - url_close_dyn_buf(dyn_bc, &buf); + avio_close_dyn_buf(dyn_bc, &buf); av_free(buf); } } + for (i = 0; i < nut->avf->nb_chapters; i++) { + ret = avio_open_dyn_buf(&dyn_bc); + if (ret < 0) + return ret; + ret = write_chapter(nut, dyn_bc, i); + if (ret < 0) { + uint8_t *buf; + avio_close_dyn_buf(dyn_bc, &buf); + av_freep(&buf); + return ret; + } + put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE); + } + nut->last_syncpoint_pos= INT_MIN; nut->header_count++; return 0; } -static int write_header(AVFormatContext *s){ +static int nut_write_header(AVFormatContext *s){ NUTContext *nut = s->priv_data; - ByteIOContext *bc = s->pb; - int i, j; + AVIOContext *bc = s->pb; + int i, j, ret; nut->avf= s; nut->stream = av_mallocz(sizeof(StreamContext)*s->nb_streams); - nut->time_base= av_mallocz(sizeof(AVRational )*s->nb_streams); + if (s->nb_chapters) + nut->chapter = av_mallocz(sizeof(ChapterContext)*s->nb_chapters); + nut->time_base= av_mallocz(sizeof(AVRational )*(s->nb_streams + + s->nb_chapters)); + if (!nut->stream || (s->nb_chapters && !nut->chapter) || !nut->time_base) { + av_freep(&nut->stream); + av_freep(&nut->chapter); + av_freep(&nut->time_base); + return AVERROR(ENOMEM); + } for(i=0; inb_streams; i++){ AVStream *st= s->streams[i]; @@ -566,7 +603,7 @@ static int write_header(AVFormatContext *s){ AVRational time_base; ff_parse_specific_params(st->codec, &time_base.den, &ssize, &time_base.num); - av_set_pts_info(st, 64, time_base.num, time_base.den); + avpriv_set_pts_info(st, 64, time_base.num, time_base.den); for(j=0; jtime_base_count; j++){ if(!memcmp(&time_base, &nut->time_base[j], sizeof(AVRational))){ @@ -578,11 +615,25 @@ static int write_header(AVFormatContext *s){ if(j==nut->time_base_count) nut->time_base_count++; - if(av_q2d(time_base) >= 0.001) + if(INT64_C(1000) * time_base.num >= time_base.den) nut->stream[i].msb_pts_shift = 7; else nut->stream[i].msb_pts_shift = 14; - nut->stream[i].max_pts_distance= FFMAX(1/av_q2d(time_base), 1); + nut->stream[i].max_pts_distance= FFMAX(time_base.den, time_base.num) / time_base.num; + } + + for (i = 0; i < s->nb_chapters; i++) { + AVChapter *ch = s->chapters[i]; + + for (j = 0; j < nut->time_base_count; j++) { + if (!memcmp(&ch->time_base, &nut->time_base[j], sizeof(AVRational))) + break; + } + + nut->time_base[j] = ch->time_base; + nut->chapter[i].time_base = &nut->time_base[j]; + if(j == nut->time_base_count) + nut->time_base_count++; } nut->max_distance = MAX_DISTANCE; @@ -590,12 +641,13 @@ static int write_header(AVFormatContext *s){ build_frame_code(s); assert(nut->frame_code['N'].flags == FLAG_INVALID); - put_buffer(bc, ID_STRING, strlen(ID_STRING)); - put_byte(bc, 0); + avio_write(bc, ID_STRING, strlen(ID_STRING)); + avio_w8(bc, 0); - write_headers(nut, bc); + if ((ret = write_headers(s, bc)) < 0) + return ret; - put_flush_packet(bc); + avio_flush(bc); //FIXME index @@ -605,7 +657,7 @@ static int write_header(AVFormatContext *s){ static int get_needed_flags(NUTContext *nut, StreamContext *nus, FrameCode *fc, AVPacket *pkt){ int flags= 0; - if(pkt->flags & PKT_FLAG_KEY ) flags |= FLAG_KEY; + if(pkt->flags & AV_PKT_FLAG_KEY ) flags |= FLAG_KEY; if(pkt->stream_index != fc->stream_id ) flags |= FLAG_STREAM_ID; if(pkt->size / fc->size_mul ) flags |= FLAG_SIZE_MSB; if(pkt->pts - nus->last_pts != fc->pts_delta) flags |= FLAG_CODED_PTS; @@ -639,30 +691,33 @@ static int find_best_header_idx(NUTContext *nut, AVPacket *pkt){ return best_i; } -static int write_packet(AVFormatContext *s, AVPacket *pkt){ +static int nut_write_packet(AVFormatContext *s, AVPacket *pkt){ NUTContext *nut = s->priv_data; StreamContext *nus= &nut->stream[pkt->stream_index]; - ByteIOContext *bc = s->pb, *dyn_bc; + AVIOContext *bc = s->pb, *dyn_bc; FrameCode *fc; int64_t coded_pts; int best_length, frame_code, flags, needed_flags, i, header_idx, best_header_idx; - int key_frame = !!(pkt->flags & PKT_FLAG_KEY); + int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY); int store_sp=0; int ret; - if(1LL<<(20+3*nut->header_count) <= url_ftell(bc)) - write_headers(nut, bc); + if(pkt->pts < 0) + return -1; + + if(1LL<<(20+3*nut->header_count) <= avio_tell(bc)) + write_headers(s, bc); if(key_frame && !(nus->last_flags & FLAG_KEY)) store_sp= 1; - if(pkt->size + 30/*FIXME check*/ + url_ftell(bc) >= nut->last_syncpoint_pos + nut->max_distance) + if(pkt->size + 30/*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance) store_sp= 1; //FIXME: Ensure store_sp is 1 in the first place. if(store_sp){ - syncpoint_t *sp, dummy= {.pos= INT64_MAX}; + Syncpoint *sp, dummy= {.pos= INT64_MAX}; ff_nut_reset_ts(nut, *nus->time_base, pkt->dts); for(i=0; inb_streams; i++){ @@ -676,14 +731,15 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){ } if(dummy.pos == INT64_MAX) dummy.pos= 0; - sp= av_tree_find(nut->syncpoints, &dummy, ff_nut_sp_pos_cmp, NULL); + sp= av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp, + NULL); - nut->last_syncpoint_pos= url_ftell(bc); - ret = url_open_dyn_buf(&dyn_bc); + nut->last_syncpoint_pos= avio_tell(bc); + ret = avio_open_dyn_buf(&dyn_bc); if(ret < 0) return ret; - put_t(nut, nus, dyn_bc, pkt->dts); - put_v(dyn_bc, sp ? (nut->last_syncpoint_pos - sp->pos)>>4 : 0); + put_tt(nut, nus->time_base, dyn_bc, pkt->dts); + ff_put_v(dyn_bc, sp ? (nut->last_syncpoint_pos - sp->pos)>>4 : 0); put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE); ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0/*unused*/, pkt->dts); @@ -719,18 +775,18 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){ continue; if(flags & FLAG_STREAM_ID) - length+= get_length(pkt->stream_index); + length+= ff_get_v_length(pkt->stream_index); if(pkt->size % fc->size_mul != fc->size_lsb) continue; if(flags & FLAG_SIZE_MSB) - length += get_length(pkt->size / fc->size_mul); + length += ff_get_v_length(pkt->size / fc->size_mul); if(flags & FLAG_CHECKSUM) length+=4; if(flags & FLAG_CODED_PTS) - length += get_length(coded_pts); + length += ff_get_v_length(coded_pts); if( (flags & FLAG_CODED) && nut->header_len[best_header_idx] > nut->header_len[fc->header_idx]+1){ @@ -758,21 +814,21 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){ needed_flags= get_needed_flags(nut, nus, fc, pkt); header_idx= fc->header_idx; - init_checksum(bc, ff_crc04C11DB7_update, 0); - put_byte(bc, frame_code); + ffio_init_checksum(bc, ff_crc04C11DB7_update, 0); + avio_w8(bc, frame_code); if(flags & FLAG_CODED){ - put_v(bc, (flags^needed_flags) & ~(FLAG_CODED)); + ff_put_v(bc, (flags^needed_flags) & ~(FLAG_CODED)); flags = needed_flags; } - if(flags & FLAG_STREAM_ID) put_v(bc, pkt->stream_index); - if(flags & FLAG_CODED_PTS) put_v(bc, coded_pts); - if(flags & FLAG_SIZE_MSB) put_v(bc, pkt->size / fc->size_mul); - if(flags & FLAG_HEADER_IDX) put_v(bc, header_idx= best_header_idx); + if(flags & FLAG_STREAM_ID) ff_put_v(bc, pkt->stream_index); + if(flags & FLAG_CODED_PTS) ff_put_v(bc, coded_pts); + if(flags & FLAG_SIZE_MSB) ff_put_v(bc, pkt->size / fc->size_mul); + if(flags & FLAG_HEADER_IDX) ff_put_v(bc, header_idx= best_header_idx); - if(flags & FLAG_CHECKSUM) put_le32(bc, get_checksum(bc)); - else get_checksum(bc); + if(flags & FLAG_CHECKSUM) avio_wl32(bc, ffio_get_checksum(bc)); + else ffio_get_checksum(bc); - put_buffer(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]); + avio_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]); nus->last_flags= flags; nus->last_pts= pkt->pts; @@ -789,34 +845,36 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){ return 0; } -static int write_trailer(AVFormatContext *s){ +static int nut_write_trailer(AVFormatContext *s){ NUTContext *nut= s->priv_data; - ByteIOContext *bc= s->pb; + AVIOContext *bc= s->pb; while(nut->header_count<3) - write_headers(nut, bc); - put_flush_packet(bc); + write_headers(s, bc); + avio_flush(bc); + ff_nut_free_sp(nut); + av_freep(&nut->stream); + av_freep(&nut->chapter); + av_freep(&nut->time_base); return 0; } -AVOutputFormat nut_muxer = { - "nut", - "nut format", - "video/x-nut", - "nut", - sizeof(NUTContext), -#ifdef CONFIG_LIBVORBIS - CODEC_ID_VORBIS, -#elif defined(CONFIG_LIBMP3LAME) - CODEC_ID_MP3, -#else - CODEC_ID_MP2, /* AC3 needs liba52 decoder */ -#endif - CODEC_ID_MPEG4, - write_header, - write_packet, - write_trailer, - .flags = AVFMT_GLOBALHEADER, - .codec_tag= (const AVCodecTag*[]){codec_bmp_tags, codec_wav_tags, ff_nut_subtitle_tags, 0}, +AVOutputFormat ff_nut_muxer = { + .name = "nut", + .long_name = NULL_IF_CONFIG_SMALL("NUT"), + .mime_type = "video/x-nut", + .extensions = "nut", + .priv_data_size = sizeof(NUTContext), + .audio_codec = CONFIG_LIBVORBIS ? CODEC_ID_VORBIS : + CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_MP2, + .video_codec = CODEC_ID_MPEG4, + .write_header = nut_write_header, + .write_packet = nut_write_packet, + .write_trailer = nut_write_trailer, + .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, + .codec_tag = (const AVCodecTag * const []){ + ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags, + ff_nut_subtitle_tags, 0 + }, };