#include "avc.h"
#include "libavcodec/get_bits.h"
#include "libavcodec/put_bits.h"
+#include "internal.h"
+#include "libavutil/avstring.h"
#undef NDEBUG
#include <assert.h>
return updateSize(pb, pos);
}
+static int mov_write_rtp_tag(ByteIOContext *pb, MOVTrack *track)
+{
+ int64_t pos = url_ftell(pb);
+ put_be32(pb, 0); /* size */
+ put_tag(pb, "rtp ");
+ put_be32(pb, 0); /* Reserved */
+ put_be16(pb, 0); /* Reserved */
+ put_be16(pb, 1); /* Data-reference index */
+
+ put_be16(pb, 1); /* Hint track version */
+ put_be16(pb, 1); /* Highest compatible version */
+ put_be32(pb, track->max_packet_size); /* Max packet size */
+
+ put_be32(pb, 12); /* size */
+ put_tag(pb, "tims");
+ put_be32(pb, track->timescale);
+
+ return updateSize(pb, pos);
+}
+
static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
mov_write_audio_tag(pb, track);
else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)
mov_write_subtitle_tag(pb, track);
+ else if (track->enc->codec_tag == MKTAG('r','t','p',' '))
+ mov_write_rtp_tag(pb, track);
return updateSize(pb, pos);
}
put_tag(pb, "stbl");
mov_write_stsd_tag(pb, track);
mov_write_stts_tag(pb, track);
- if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO &&
+ if ((track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
+ track->enc->codec_tag == MKTAG('r','t','p',' ')) &&
track->hasKeyframes && track->hasKeyframes < track->entry)
mov_write_stss_tag(pb, track, MOV_SYNC_SAMPLE);
if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
if (track->tag == MKTAG('t','x','3','g')) hdlr_type = "sbtl";
else hdlr_type = "text";
descr = "SubtitleHandler";
+ } else if (track->enc->codec_tag == MKTAG('r','t','p',' ')) {
+ hdlr_type = "hint";
+ descr = "HintHandler";
}
}
return updateSize(pb, pos);
}
+static int mov_write_hmhd_tag(ByteIOContext *pb)
+{
+ /* This atom must be present, but leaving the values at zero
+ * seems harmless. */
+ put_be32(pb, 28); /* size */
+ put_tag(pb, "hmhd");
+ put_be32(pb, 0); /* version, flags */
+ put_be16(pb, 0); /* maxPDUsize */
+ put_be16(pb, 0); /* avgPDUsize */
+ put_be32(pb, 0); /* maxbitrate */
+ put_be32(pb, 0); /* avgbitrate */
+ put_be32(pb, 0); /* reserved */
+ return 28;
+}
+
static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack *track)
{
int64_t pos = url_ftell(pb);
else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) {
if (track->tag == MKTAG('t','e','x','t')) mov_write_gmhd_tag(pb);
else mov_write_nmhd_tag(pb);
+ } else if (track->tag == MKTAG('r','t','p',' ')) {
+ mov_write_hmhd_tag(pb);
}
if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
mov_write_hdlr_tag(pb, NULL);
return 0x34;
}
+static int mov_write_udta_sdp(ByteIOContext *pb, AVCodecContext *ctx, int index)
+{
+ char buf[1000] = "";
+ int len;
+
+ ff_sdp_write_media(buf, sizeof(buf), ctx, NULL, 0, 0);
+ av_strlcatf(buf, sizeof(buf), "a=control:streamid=%d\r\n", index);
+ len = strlen(buf);
+
+ put_be32(pb, len + 24);
+ put_tag (pb, "udta");
+ put_be32(pb, len + 16);
+ put_tag (pb, "hnti");
+ put_be32(pb, len + 8);
+ put_tag (pb, "sdp ");
+ put_buffer(pb, buf, len);
+ return len + 24;
+}
+
static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
{
int64_t pos = url_ftell(pb);
mov_write_mdia_tag(pb, track);
if (track->mode == MODE_PSP)
mov_write_uuid_tag_psp(pb,track); // PSP Movies require this uuid box
+ if (track->tag == MKTAG('r','t','p',' '))
+ mov_write_udta_sdp(pb, track->rtp_ctx->streams[0]->codec, track->trackID);
return updateSize(pb, pos);
}
put_be32(pb, 0); /* size */
put_tag(pb, "ilst");
mov_write_string_metadata(s, pb, "\251nam", "title" , 1);
- mov_write_string_metadata(s, pb, "\251ART", "author" , 1);
+ mov_write_string_metadata(s, pb, "\251ART", "artist" , 1);
mov_write_string_metadata(s, pb, "aART", "album_artist", 1);
mov_write_string_metadata(s, pb, "\251wrt", "composer" , 1);
mov_write_string_metadata(s, pb, "\251alb", "album" , 1);
put_be16(pb, language_code("eng")); /* language */
put_buffer(pb, t->value, strlen(t->value)+1); /* UTF8 string value */
if (!strcmp(tag, "albm") &&
- (t = av_metadata_get(s->metadata, "date", NULL, 0)))
+ (t = av_metadata_get(s->metadata, "track", NULL, 0)))
put_byte(pb, atoi(t->value));
}
return updateSize(pb, pos);
return ret;
if (mov->mode & MODE_3GP) {
+ mov_write_3gp_udta_tag(pb_buf, s, "perf", "artist");
mov_write_3gp_udta_tag(pb_buf, s, "titl", "title");
mov_write_3gp_udta_tag(pb_buf, s, "auth", "author");
mov_write_3gp_udta_tag(pb_buf, s, "gnre", "genre");
mov->tracks[i].tref_tag = MKTAG('c','h','a','p');
mov->tracks[i].tref_id = mov->tracks[mov->chapter_track].trackID;
}
+ for (i = 0; i < mov->nb_streams; i++) {
+ if (mov->tracks[i].tag == MKTAG('r','t','p',' ')) {
+ mov->tracks[i].tref_tag = MKTAG('h','i','n','t');
+ mov->tracks[i].tref_id =
+ mov->tracks[mov->tracks[i].src_track].trackID;
+ }
+ }
mov_write_mvhd_tag(pb, mov);
//mov_write_iods_tag(pb, mov);
return 0;
}
-static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
+int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MOVMuxContext *mov = s->priv_data;
ByteIOContext *pb = s->pb;
mov->mdat_size += size;
put_flush_packet(pb);
+
+ if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams)
+ ff_mov_add_hinted_packet(s, pkt, trk->hint_track, trk->entry);
return 0;
}
pkt.data = av_malloc(pkt.size);
AV_WB16(pkt.data, len);
memcpy(pkt.data+2, t->value, len);
- mov_write_packet(s, &pkt);
+ ff_mov_write_packet(s, &pkt);
av_freep(&pkt.data);
}
}
{
ByteIOContext *pb = s->pb;
MOVMuxContext *mov = s->priv_data;
- int i;
+ int i, hint_track = 0;
if (url_is_streamed(s->pb)) {
av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
if (mov->mode & (MODE_MOV|MODE_IPOD) && s->nb_chapters)
mov->chapter_track = mov->nb_streams++;
+ if (s->flags & AVFMT_FLAG_RTP_HINT) {
+ /* Add hint tracks for each audio and video stream */
+ hint_track = mov->nb_streams;
+ for (i = 0; i < s->nb_streams; i++) {
+ AVStream *st = s->streams[i];
+ if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
+ st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+ mov->nb_streams++;
+ }
+ }
+ }
+
mov->tracks = av_mallocz(mov->nb_streams*sizeof(*mov->tracks));
if (!mov->tracks)
return AVERROR(ENOMEM);
"codec not currently supported in container\n", i);
goto error;
}
+ /* If hinting of this track is enabled by a later hint track,
+ * this is updated. */
+ track->hint_track = -1;
if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||
track->tag == MKTAG('m','x','4','p') || track->tag == MKTAG('m','x','4','n') ||
if (mov->chapter_track)
mov_create_chapter_track(s, mov->chapter_track);
+ if (s->flags & AVFMT_FLAG_RTP_HINT) {
+ /* Initialize the hint tracks for each audio and video stream */
+ for (i = 0; i < s->nb_streams; i++) {
+ AVStream *st = s->streams[i];
+ if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
+ st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+ ff_mov_init_hinting(s, hint_track, i);
+ hint_track++;
+ }
+ }
+ }
+
put_flush_packet(pb);
return 0;
av_freep(&mov->tracks[mov->chapter_track].enc);
for (i=0; i<mov->nb_streams; i++) {
+ if (mov->tracks[i].tag == MKTAG('r','t','p',' '))
+ ff_mov_close_hinting(&mov->tracks[i]);
av_freep(&mov->tracks[i].cluster);
if(mov->tracks[i].vosLen) av_free(mov->tracks[i].vosData);
CODEC_ID_AAC,
CODEC_ID_MPEG4,
mov_write_header,
- mov_write_packet,
+ ff_mov_write_packet,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
.codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0},
CODEC_ID_AMR_NB,
CODEC_ID_H263,
mov_write_header,
- mov_write_packet,
+ ff_mov_write_packet,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
CODEC_ID_AAC,
CODEC_ID_MPEG4,
mov_write_header,
- mov_write_packet,
+ ff_mov_write_packet,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
CODEC_ID_AAC,
CODEC_ID_MPEG4,
mov_write_header,
- mov_write_packet,
+ ff_mov_write_packet,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
CODEC_ID_AMR_NB,
CODEC_ID_H263,
mov_write_header,
- mov_write_packet,
+ ff_mov_write_packet,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
CODEC_ID_AAC,
CODEC_ID_H264,
mov_write_header,
- mov_write_packet,
+ ff_mov_write_packet,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},