* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "libavutil/intreadwrite.h"
+#include "libavutil/tree.h"
+#include "libavcodec/mpegaudiodata.h"
#include "nut.h"
-#include "tree.h"
-#include "mpegaudiodata.h"
+#include "internal.h"
static int find_expected_header(AVCodecContext *c, int size, int key_frame, uint8_t out[64]){
int sample_rate= c->sample_rate;
header |= 1<<16; //no crc
AV_WB32(out, header);
if(size <= 0)
- return 2; //we guess theres no crc, if there is one the user clearly doesnt care about overhead
+ return 2; //we guess there is no crc, if there is one the user clearly does not care about overhead
if(bitrate_index == 30)
return -1; //something is wrong ...
header |= (bitrate_index&1)<<9;
return 2; //FIXME actually put the needed ones in build_elision_headers()
- return 3; //we guess that the private bit isnt set
-//FIXME the above asumtations should be checked, if these turn out false too often something should be done
+ return 3; //we guess that the private bit is not set
+//FIXME the above assumptions should be checked, if these turn out false too often something should be done
}
return 0;
}
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
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;
}
/**
- * Gets the length in bytes which is needed to store val as v.
+ * Get the length in bytes which is needed to store val as v.
*/
static int get_length(uint64_t val){
int i=1;
put_byte(bc, val&127);
}
-static void put_t(NUTContext *nut, StreamContext *nus, ByteIOContext *bc, uint64_t val){
+static void put_tt(NUTContext *nut, StreamContext *nus, ByteIOContext *bc, uint64_t val){
val *= nut->time_base_count;
val += nus->time_base - nut->time_base;
put_v(bc, val);
}
/**
- * Stores a string as vb.
+ * Store a string as vb.
*/
static void put_str(ByteIOContext *bc, const char *string){
int len= strlen(string);
}
}
-static int write_streamheader(NUTContext *nut, ByteIOContext *bc, AVCodecContext *codec, int i){
+static int write_streamheader(AVFormatContext *avctx, ByteIOContext *bc, AVStream *st, int i){
+ NUTContext *nut = avctx->priv_data;
+ AVCodecContext *codec = st->codec;
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;
+ case AVMEDIA_TYPE_VIDEO: put_v(bc, 0); break;
+ case AVMEDIA_TYPE_AUDIO: put_v(bc, 1); break;
+ case AVMEDIA_TYPE_SUBTITLE: put_v(bc, 2); break;
default : put_v(bc, 3); break;
}
put_v(bc, 4);
if (codec->codec_tag){
put_le32(bc, codec->codec_tag);
- }else
- return -1;
+ } 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_buffer(bc, codec->extradata, codec->extradata_size);
switch(codec->codec_type){
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
put_v(bc, codec->sample_rate);
put_v(bc, 1);
put_v(bc, codec->channels);
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
put_v(bc, codec->width);
put_v(bc, codec->height);
- if(codec->sample_aspect_ratio.num<=0 || codec->sample_aspect_ratio.den<=0){
+ if(st->sample_aspect_ratio.num<=0 || st->sample_aspect_ratio.den<=0){
put_v(bc, 0);
put_v(bc, 0);
}else{
- put_v(bc, codec->sample_aspect_ratio.num);
- put_v(bc, codec->sample_aspect_ratio.den);
+ put_v(bc, st->sample_aspect_ratio.num);
+ put_v(bc, st->sample_aspect_ratio.den);
}
put_v(bc, 0); /* csp type -- unknown */
break;
static int write_globalinfo(NUTContext *nut, ByteIOContext *bc){
AVFormatContext *s= nut->avf;
+ AVMetadataTag *t = NULL;
ByteIOContext *dyn_bc;
uint8_t *dyn_buf=NULL;
int count=0, dyn_size;
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_metadata_get(s->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
+ count += add_info(dyn_bc, t->key, t->value);
put_v(bc, 0); //stream_if_plus1
put_v(bc, 0); //chapter_id
return count;
}
-static int write_headers(NUTContext *nut, ByteIOContext *bc){
+static int write_headers(AVFormatContext *avctx, ByteIOContext *bc){
+ NUTContext *nut = avctx->priv_data;
ByteIOContext *dyn_bc;
int i, ret;
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);
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);
}
static int write_header(AVFormatContext *s){
NUTContext *nut = s->priv_data;
ByteIOContext *bc = s->pb;
- int i, j;
+ int i, j, ret;
nut->avf= s;
put_buffer(bc, ID_STRING, strlen(ID_STRING));
put_byte(bc, 0);
- write_headers(nut, bc);
+ if ((ret = write_headers(s, bc)) < 0)
+ return ret;
put_flush_packet(bc);
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;
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(pkt->pts < 0)
+ return -1;
+
if(1LL<<(20+3*nut->header_count) <= url_ftell(bc))
- write_headers(nut, bc);
+ write_headers(s, bc);
if(key_frame && !(nus->last_flags & FLAG_KEY))
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; i<s->nb_streams; i++){
}
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);
if(ret < 0)
return ret;
- put_t(nut, nus, dyn_bc, pkt->dts);
+ put_tt(nut, nus, dyn_bc, pkt->dts);
put_v(dyn_bc, sp ? (nut->last_syncpoint_pos - sp->pos)>>4 : 0);
put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE);
ByteIOContext *bc= s->pb;
while(nut->header_count<3)
- write_headers(nut, bc);
+ write_headers(s, bc);
put_flush_packet(bc);
+ ff_nut_free_sp(nut);
+ av_freep(&nut->stream);
+ av_freep(&nut->time_base);
return 0;
}
AVOutputFormat nut_muxer = {
"nut",
- "nut format",
+ NULL_IF_CONFIG_SMALL("NUT format"),
"video/x-nut",
"nut",
sizeof(NUTContext),
-#ifdef CONFIG_LIBVORBIS
+#if CONFIG_LIBVORBIS
CODEC_ID_VORBIS,
-#elif defined(CONFIG_LIBMP3LAME)
+#elif CONFIG_LIBMP3LAME
CODEC_ID_MP3,
#else
- CODEC_ID_MP2, /* AC3 needs liba52 decoder */
+ CODEC_ID_MP2,
#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},
+ .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 },
+ .metadata_conv = ff_nut_metadata_conv,
};
projects / ffmpeg / blobdiff