* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include <stdint.h>
+#include <inttypes.h>
+
#include "movenc.h"
#include "avformat.h"
#include "avio_internal.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/dict.h"
+#include "hevc.h"
#include "rtpenc.h"
#include "mov_chan.h"
{ "frag_custom", "Flush fragments on caller requests", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_CUSTOM}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
{ "isml", "Create a live smooth streaming feed (for pushing to a publishing point)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_ISML}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
{ "faststart", "Run a second pass to put the index (moov atom) at the beginning of the file", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FASTSTART}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+ { "omit_tfhd_offset", "Omit the base data offset in tfhd atoms", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_OMIT_TFHD_OFFSET}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags),
{ "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
{ "iods_audio_profile", "iods audio profile atom.", offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
{ "min_frag_duration", "Minimum fragment duration", offsetof(MOVMuxContext, min_fragment_duration), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
{ "frag_size", "Maximum fragment size", offsetof(MOVMuxContext, max_fragment_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
{ "ism_lookahead", "Number of lookahead entries for ISM files", offsetof(MOVMuxContext, ism_lookahead), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
+ { "brand", "Override major brand", offsetof(MOVMuxContext, major_brand), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = AV_OPT_FLAG_ENCODING_PARAM },
{ NULL },
};
// the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio)
// plus 1 bit to indicate upstream and 1 bit set to 1 (reserved)
- if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
+ if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
+ avio_w8(pb, (0x38 << 2) | 1); // flags (= NeroSubpicStream)
+ else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
avio_w8(pb, 0x15); // flags (= Audiostream)
else
avio_w8(pb, 0x11); // flags (= Visualstream)
put_bits(&pbc, 1, !slices); /* no slice code */
put_bits(&pbc, 1, 0); /* no bframe */
put_bits(&pbc, 1, 0); /* reserved */
- put_bits32(&pbc, track->enc->time_base.den); /* framerate */
+
+ /* framerate */
+ if (track->st->avg_frame_rate.num > 0 && track->st->avg_frame_rate.den > 0)
+ put_bits32(&pbc, track->st->avg_frame_rate.num / track->st->avg_frame_rate.den);
+ else
+ put_bits32(&pbc, 0xffffffff);
+
flush_put_bits(&pbc);
av_free(unescaped);
return update_size(pb, pos);
}
+static int mov_write_hvcc_tag(AVIOContext *pb, MOVTrack *track)
+{
+ int64_t pos = avio_tell(pb);
+
+ avio_wb32(pb, 0);
+ ffio_wfourcc(pb, "hvcC");
+ ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 0);
+ return update_size(pb, pos);
+}
+
/* also used by all avid codecs (dv, imx, meridien) and their variants */
static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track)
{
return 0;
if (track->enc->codec_id == AV_CODEC_ID_H264) tag = MKTAG('a','v','c','1');
+ else if (track->enc->codec_id == AV_CODEC_ID_HEVC) tag = MKTAG('h','e','v','1');
else if (track->enc->codec_id == AV_CODEC_ID_AC3) tag = MKTAG('a','c','-','3');
else if (track->enc->codec_id == AV_CODEC_ID_DIRAC) tag = MKTAG('d','r','a','c');
else if (track->enc->codec_id == AV_CODEC_ID_MOV_TEXT) tag = MKTAG('t','x','3','g');
else if (track->enc->codec_id == AV_CODEC_ID_VC1) tag = MKTAG('v','c','-','1');
else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) tag = MKTAG('m','p','4','v');
else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) tag = MKTAG('m','p','4','a');
+ else if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE) tag = MKTAG('m','p','4','s');
return tag;
}
else if (track->enc->pix_fmt == AV_PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');
else tag = MKTAG('d','v','p','p');
else if (track->enc->height == 720) /* HD 720 line */
- if (track->enc->time_base.den == 50) tag = MKTAG('d','v','h','q');
+ if (track->st->time_base.den == 50) tag = MKTAG('d','v','h','q');
else tag = MKTAG('d','v','h','p');
else if (track->enc->height == 1080) /* HD 1080 line */
- if (track->enc->time_base.den == 25) tag = MKTAG('d','v','h','5');
+ if (track->st->time_base.den == 25) tag = MKTAG('d','v','h','5');
else tag = MKTAG('d','v','h','6');
else {
av_log(s, AV_LOG_ERROR, "unsupported height for dv codec\n");
{ AV_CODEC_ID_NONE, 0 },
};
+static const AVCodecTag codec_f4v_tags[] = {
+ { AV_CODEC_ID_MP3, MKTAG('.','m','p','3') },
+ { AV_CODEC_ID_AAC, MKTAG('m','p','4','a') },
+ { AV_CODEC_ID_H264, MKTAG('a','v','c','1') },
+ { AV_CODEC_ID_VP6A, MKTAG('V','P','6','A') },
+ { AV_CODEC_ID_VP6F, MKTAG('V','P','6','F') },
+ { AV_CODEC_ID_NONE, 0 },
+};
+
static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
{
int tag;
tag = ipod_get_codec_tag(s, track);
else if (track->mode & MODE_3GP)
tag = ff_codec_get_tag(codec_3gp_tags, track->enc->codec_id);
+ else if (track->mode == MODE_F4V)
+ tag = ff_codec_get_tag(codec_f4v_tags, track->enc->codec_id);
else
tag = mov_get_codec_tag(s, track);
avio_wb16(pb, 0); /* Reserved */
avio_wb16(pb, 1); /* Data-reference index */
- if (track->enc->extradata_size)
+ if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
+ mov_write_esds_tag(pb, track);
+ else if (track->enc->extradata_size)
avio_write(pb, track->enc->extradata, track->enc->extradata_size);
return update_size(pb, pos);
static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
{
+ AVDictionaryEntry *encoder;
int64_t pos = avio_tell(pb);
char compressor_name[32] = { 0 };
avio_wb16(pb, 1); /* Frame count (= 1) */
/* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */
- if (track->mode == MODE_MOV && track->enc->codec && track->enc->codec->name)
- av_strlcpy(compressor_name, track->enc->codec->name, 32);
+ if (track->mode == MODE_MOV &&
+ (encoder = av_dict_get(track->st->metadata, "encoder", NULL, 0)))
+ av_strlcpy(compressor_name, encoder->value, 32);
avio_w8(pb, strlen(compressor_name));
avio_write(pb, compressor_name, 31);
mov_write_svq3_tag(pb);
else if (track->enc->codec_id == AV_CODEC_ID_DNXHD)
mov_write_avid_tag(pb, track);
+ else if (track->enc->codec_id == AV_CODEC_ID_HEVC)
+ mov_write_hvcc_tag(pb, track);
else if (track->enc->codec_id == AV_CODEC_ID_H264) {
mov_write_avcc_tag(pb, track);
if (track->mode == MODE_IPOD)
mov_write_fiel_tag(pb, track);
else if (track->enc->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
mov_write_dvc1_tag(pb, track);
- else if (track->vos_len > 0)
+ else if (track->enc->codec_id == AV_CODEC_ID_VP6F ||
+ track->enc->codec_id == AV_CODEC_ID_VP6A) {
+ /* Don't write any potential extradata here - the cropping
+ * is signalled via the normal width/height fields. */
+ } else if (track->vos_len > 0)
mov_write_glbl_tag(pb, track);
if (track->enc->sample_aspect_ratio.den && track->enc->sample_aspect_ratio.num &&
return 0x14;
}
+static int is_clcp_track(MOVTrack *track)
+{
+ return track->tag == MKTAG('c','7','0','8') ||
+ track->tag == MKTAG('c','6','0','8');
+}
+
static int mov_write_hdlr_tag(AVIOContext *pb, MOVTrack *track)
{
const char *hdlr, *descr = NULL, *hdlr_type = NULL;
hdlr_type = "soun";
descr = "SoundHandler";
} else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) {
- if (track->tag == MKTAG('t','x','3','g')) hdlr_type = "sbtl";
- else hdlr_type = "text";
+ if (track->tag == MKTAG('t','x','3','g')) {
+ hdlr_type = "sbtl";
+ } else if (track->tag == MKTAG('m','p','4','s')) {
+ hdlr_type = "subp";
+ } else if (is_clcp_track(track)) {
+ hdlr_type = "clcp";
+ } else {
+ hdlr_type = "text";
+ }
descr = "SubtitleHandler";
} else if (track->enc->codec_tag == MKTAG('r','t','p',' ')) {
hdlr_type = "hint";
else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
mov_write_smhd_tag(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);
+ if (track->tag == MKTAG('t','e','x','t') || is_clcp_track(track)) {
+ mov_write_gmhd_tag(pb);
+ } else {
+ mov_write_nmhd_tag(pb);
+ }
} else if (track->tag == MKTAG('r','t','p',' ')) {
mov_write_hmhd_tag(pb);
} else if (track->tag == MKTAG('t','m','c','d')) {
avio_wb32(pb, width << 16);
avio_wb32(pb, track->enc->height << 16);
+ avio_wb32(pb, 20);
+ ffio_wfourcc(pb, "prof");
+ avio_wb32(pb, 0);
+ avio_wb32(pb, width << 16);
+ avio_wb32(pb, track->enc->height << 16);
+
avio_wb32(pb, 20);
ffio_wfourcc(pb, "enof");
avio_wb32(pb, 0);
ffio_wfourcc(pb, "trak");
mov_write_tkhd_tag(pb, track, st);
if (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS ||
- (track->entry && track->cluster[0].dts)) {
+ (track->entry && track->cluster[0].dts) ||
+ is_clcp_track(track)) {
if (!(mov->flags & FF_MOV_FLAG_FRAGMENT))
mov_write_edts_tag(pb, track); // PSP Movies require edts box
}
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);
- if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO && track->mode == MODE_MOV) {
- double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
- if (0.0 != sample_aspect_ratio && 1.0 != sample_aspect_ratio)
+ if (track->mode == MODE_MOV) {
+ if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
+ double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
+ if ((0.0 != sample_aspect_ratio && 1.0 != sample_aspect_ratio)) {
+ mov_write_tapt_tag(pb, track);
+ }
+ }
+ if (is_clcp_track(track)) {
mov_write_tapt_tag(pb, track);
+ }
}
return update_size(pb, pos);
}
mov_write_string_metadata(s, pb, "\251wrt", "composer" , 1);
mov_write_string_metadata(s, pb, "\251alb", "album" , 1);
mov_write_string_metadata(s, pb, "\251day", "date" , 1);
- mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1);
+ if (!mov_write_string_metadata(s, pb, "\251too", "encoding_tool", 1))
+ mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1);
mov_write_string_metadata(s, pb, "\251cmt", "comment" , 1);
mov_write_string_metadata(s, pb, "\251gen", "genre" , 1);
mov_write_string_metadata(s, pb, "\251cpy", "copyright", 1);
uint8_t *buf;
for (i = 0; i < s->nb_streams; i++)
- if (mov->tracks[i].enc->flags & CODEC_FLAG_BITEXACT) {
+ if (s->flags & AVFMT_FLAG_BITEXACT) {
return 0;
}
return 0;
}
-static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track,
- int64_t moof_offset)
+static int mov_write_tfhd_tag(AVIOContext *pb, MOVMuxContext *mov,
+ MOVTrack *track, int64_t moof_offset)
{
int64_t pos = avio_tell(pb);
uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
} else {
flags |= MOV_TFHD_DEFAULT_FLAGS;
}
+ if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET)
+ flags &= ~MOV_TFHD_BASE_DATA_OFFSET;
/* Don't set a default sample size, the silverlight player refuses
* to play files with that set. Don't set a default sample duration,
(MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC);
}
-static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track)
+static int mov_write_trun_tag(AVIOContext *pb, MOVMuxContext *mov,
+ MOVTrack *track, int moof_size)
{
int64_t pos = avio_tell(pb);
uint32_t flags = MOV_TRUN_DATA_OFFSET;
avio_wb24(pb, flags);
avio_wb32(pb, track->entry); /* sample count */
- track->moof_size_offset = avio_tell(pb);
- avio_wb32(pb, 0); /* data offset */
+ if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET &&
+ !(mov->flags & FF_MOV_FLAG_SEPARATE_MOOF) &&
+ track->track_id != 1)
+ avio_wb32(pb, 0); /* Later tracks follow immediately after the previous one */
+ else
+ avio_wb32(pb, moof_size + 8 + track->data_offset +
+ track->cluster[0].pos); /* data offset */
if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS)
avio_wb32(pb, get_sample_flags(track, &track->cluster[0]));
}
static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov,
- MOVTrack *track, int64_t moof_offset)
+ MOVTrack *track, int64_t moof_offset,
+ int moof_size)
{
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size placeholder */
ffio_wfourcc(pb, "traf");
- mov_write_tfhd_tag(pb, track, moof_offset);
- mov_write_trun_tag(pb, track);
+ mov_write_tfhd_tag(pb, mov, track, moof_offset);
+ mov_write_trun_tag(pb, mov, track, moof_size);
if (mov->mode == MODE_ISM) {
mov_write_tfxd_tag(pb, track);
return update_size(pb, pos);
}
-static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
+static int mov_write_moof_tag_internal(AVIOContext *pb, MOVMuxContext *mov,
+ int tracks, int moof_size)
{
- int64_t pos = avio_tell(pb), end;
- int i, moof_size;
+ int64_t pos = avio_tell(pb);
+ int i;
avio_wb32(pb, 0); /* size placeholder */
ffio_wfourcc(pb, "moof");
continue;
if (!track->entry)
continue;
- mov_write_traf_tag(pb, mov, track, pos);
+ mov_write_traf_tag(pb, mov, track, pos, moof_size);
}
- end = avio_tell(pb);
- moof_size = end - pos;
- for (i = 0; i < mov->nb_streams; i++) {
- MOVTrack *track = &mov->tracks[i];
- if (tracks >= 0 && i != tracks)
- continue;
- if (!track->entry)
- continue;
- avio_seek(pb, mov->tracks[i].moof_size_offset, SEEK_SET);
- avio_wb32(pb, moof_size + 8 + mov->tracks[i].data_offset);
- }
- avio_seek(pb, end, SEEK_SET);
-
return update_size(pb, pos);
}
+static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
+{
+ AVIOContext *avio_buf;
+ int ret, moof_size;
+
+ if ((ret = ffio_open_null_buf(&avio_buf)) < 0)
+ return ret;
+ mov_write_moof_tag_internal(avio_buf, mov, tracks, 0);
+ moof_size = ffio_close_null_buf(avio_buf);
+ return mov_write_moof_tag_internal(pb, mov, tracks, moof_size);
+}
+
static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
{
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "ftyp");
- if (mov->mode == MODE_3GP) {
+ if (mov->major_brand && strlen(mov->major_brand) >= 4)
+ ffio_wfourcc(pb, mov->major_brand);
+ else if (mov->mode == MODE_3GP) {
ffio_wfourcc(pb, has_h264 ? "3gp6" : "3gp4");
minor = has_h264 ? 0x100 : 0x200;
} else if (mov->mode & MODE_3G2) {
ffio_wfourcc(pb, has_video ? "M4V ":"M4A ");
else if (mov->mode == MODE_ISM)
ffio_wfourcc(pb, "isml");
+ else if (mov->mode == MODE_F4V)
+ ffio_wfourcc(pb, "f4v ");
else
ffio_wfourcc(pb, "qt ");
static void mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s)
{
+ AVStream *video_st = s->streams[0];
AVCodecContext *video_codec = s->streams[0]->codec;
AVCodecContext *audio_codec = s->streams[1]->codec;
int audio_rate = audio_codec->sample_rate;
- int frame_rate = ((video_codec->time_base.den) * (0x10000)) / (video_codec->time_base.num);
+ // TODO: should be avg_frame_rate
+ int frame_rate = ((video_st->time_base.den) * (0x10000)) / (video_st->time_base.num);
int audio_kbitrate = audio_codec->bit_rate / 1000;
int video_kbitrate = FFMIN(video_codec->bit_rate / 1000, 800 - audio_kbitrate);
if (i < mov->nb_streams)
return 0;
- if ((ret = avio_open_dyn_buf(&moov_buf)) < 0)
+ if ((ret = ffio_open_null_buf(&moov_buf)) < 0)
return ret;
mov_write_moov_tag(moov_buf, mov, s);
- buf_size = avio_close_dyn_buf(moov_buf, &buf);
- av_free(buf);
+ buf_size = ffio_close_null_buf(moov_buf);
for (i = 0; i < mov->nb_streams; i++)
mov->tracks[i].data_offset = pos + buf_size + 8;
} else {
size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size);
}
+ } else if (enc->codec_id == AV_CODEC_ID_HEVC && trk->vos_len > 6 &&
+ (AV_RB24(trk->vos_data) == 1 || AV_RB32(trk->vos_data) == 1)) {
+ /* extradata is Annex B, assume the bitstream is too and convert it */
+ if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
+ ff_hevc_annexb2mp4_buf(pkt->data, &reformatted_data, &size, 0, NULL);
+ avio_write(pb, reformatted_data, size);
+ } else {
+ size = ff_hevc_annexb2mp4(pb, pkt->data, pkt->size, 0, NULL);
+ }
} else {
avio_write(pb, pkt->data, size);
}
trk->sample_count += samples_in_chunk;
mov->mdat_size += size;
- avio_flush(pb);
-
if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams)
ff_mov_add_hinted_packet(s, pkt, trk->hint_track, trk->entry,
reformatted_data, size);
av_freep(&mov->tracks);
}
+static uint32_t rgb_to_yuv(uint32_t rgb)
+{
+ uint8_t r, g, b;
+ int y, cb, cr;
+
+ r = (rgb >> 16) & 0xFF;
+ g = (rgb >> 8) & 0xFF;
+ b = (rgb ) & 0xFF;
+
+ y = av_clip_uint8( 16. + 0.257 * r + 0.504 * g + 0.098 * b);
+ cb = av_clip_uint8(128. - 0.148 * r - 0.291 * g + 0.439 * b);
+ cr = av_clip_uint8(128. + 0.439 * r - 0.368 * g - 0.071 * b);
+
+ return (y << 16) | (cr << 8) | cb;
+}
+
+static int mov_create_dvd_sub_decoder_specific_info(MOVTrack *track,
+ AVStream *st)
+{
+ int i, width = 720, height = 480;
+ int have_palette = 0, have_size = 0;
+ uint32_t palette[16];
+ char *cur = st->codec->extradata;
+
+ while (cur && *cur) {
+ if (strncmp("palette:", cur, 8) == 0) {
+ int i, count;
+ count = sscanf(cur + 8,
+ "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32", "
+ "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32", "
+ "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32", "
+ "%06"PRIx32", %06"PRIx32", %06"PRIx32", %06"PRIx32"",
+ &palette[ 0], &palette[ 1], &palette[ 2], &palette[ 3],
+ &palette[ 4], &palette[ 5], &palette[ 6], &palette[ 7],
+ &palette[ 8], &palette[ 9], &palette[10], &palette[11],
+ &palette[12], &palette[13], &palette[14], &palette[15]);
+
+ for (i = 0; i < count; i++) {
+ palette[i] = rgb_to_yuv(palette[i]);
+ }
+ have_palette = 1;
+ } else if (!strncmp("size:", cur, 5)) {
+ sscanf(cur + 5, "%dx%d", &width, &height);
+ have_size = 1;
+ }
+ if (have_palette && have_size)
+ break;
+ cur += strcspn(cur, "\n\r");
+ cur += strspn(cur, "\n\r");
+ }
+ if (have_palette) {
+ track->vos_data = av_malloc(16*4);
+ if (!track->vos_data)
+ return AVERROR(ENOMEM);
+ for (i = 0; i < 16; i++) {
+ AV_WB32(track->vos_data + i * 4, palette[i]);
+ }
+ track->vos_len = 16 * 4;
+ }
+ st->codec->width = width;
+ st->codec->height = track->height = height;
+
+ return 0;
+}
+
static int mov_write_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
AVDictionaryEntry *t;
int i, hint_track = 0;
+ /* Default mode == MP4 */
+ mov->mode = MODE_MP4;
+
+ if (s->oformat != NULL) {
+ if (!strcmp("3gp", s->oformat->name)) mov->mode = MODE_3GP;
+ else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3GP|MODE_3G2;
+ else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV;
+ else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP;
+ else if (!strcmp("ipod",s->oformat->name)) mov->mode = MODE_IPOD;
+ else if (!strcmp("ismv",s->oformat->name)) mov->mode = MODE_ISM;
+ else if (!strcmp("f4v", s->oformat->name)) mov->mode = MODE_F4V;
+ }
+
/* Set the FRAGMENT flag if any of the fragmentation methods are
* enabled. */
if (mov->max_fragment_duration || mov->max_fragment_size ||
FF_MOV_FLAG_FRAG_CUSTOM))
mov->flags |= FF_MOV_FLAG_FRAGMENT;
+ /* Set other implicit flags immediately */
+ if (mov->mode == MODE_ISM)
+ mov->flags |= FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF |
+ FF_MOV_FLAG_FRAGMENT;
+
/* faststart: moov at the beginning of the file, if supported */
if (mov->flags & FF_MOV_FLAG_FASTSTART) {
if ((mov->flags & FF_MOV_FLAG_FRAGMENT) ||
- (s->flags & AVFMT_FLAG_CUSTOM_IO))
+ (s->flags & AVFMT_FLAG_CUSTOM_IO)) {
+ av_log(s, AV_LOG_WARNING, "The faststart flag is incompatible "
+ "with fragmentation and custom IO, disabling faststart\n");
mov->flags &= ~FF_MOV_FLAG_FASTSTART;
+ }
}
/* Non-seekable output is ok if using fragmentation. If ism_lookahead
* is enabled, we don't support non-seekable output at all. */
if (!s->pb->seekable &&
- ((!(mov->flags & FF_MOV_FLAG_FRAGMENT) &&
- !(s->oformat && !strcmp(s->oformat->name, "ismv")))
- || mov->ism_lookahead)) {
+ (!(mov->flags & FF_MOV_FLAG_FRAGMENT) || mov->ism_lookahead)) {
av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
- return -1;
+ return AVERROR(EINVAL);
}
- /* Default mode == MP4 */
- mov->mode = MODE_MP4;
- if (s->oformat != NULL) {
- if (!strcmp("3gp", s->oformat->name)) mov->mode = MODE_3GP;
- else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3GP|MODE_3G2;
- else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV;
- else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP;
- else if (!strcmp("ipod",s->oformat->name)) mov->mode = MODE_IPOD;
- else if (!strcmp("ismv",s->oformat->name)) mov->mode = MODE_ISM;
-
- mov_write_ftyp_tag(pb,s);
- if (mov->mode == MODE_PSP) {
- if (s->nb_streams != 2) {
- av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n");
- return -1;
- }
- mov_write_uuidprof_tag(pb, s);
+ mov_write_ftyp_tag(pb,s);
+ if (mov->mode == MODE_PSP) {
+ if (s->nb_streams != 2) {
+ av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n");
+ return AVERROR(EINVAL);
}
+ mov_write_uuidprof_tag(pb, s);
}
mov->nb_streams = s->nb_streams;
MOVTrack *track= &mov->tracks[i];
AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
+ track->st = st;
track->enc = st->codec;
track->language = ff_mov_iso639_to_lang(lang?lang->value:"und", mov->mode!=MODE_MOV);
if (track->language < 0)
}
track->height = track->tag >> 24 == 'n' ? 486 : 576;
}
- track->timescale = st->codec->time_base.den;
+ track->timescale = st->time_base.den;
if (track->mode == MODE_MOV && track->timescale > 100000)
av_log(s, AV_LOG_WARNING,
"WARNING codec timebase is very high. If duration is too long,\n"
goto error;
}
} else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
- track->timescale = st->codec->time_base.den;
+ track->timescale = st->time_base.den;
} else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
- track->timescale = st->codec->time_base.den;
+ track->timescale = st->time_base.den;
}
if (!track->height)
track->height = st->codec->height;
/* copy extradata if it exists */
if (st->codec->extradata_size) {
- track->vos_len = st->codec->extradata_size;
- track->vos_data = av_malloc(track->vos_len);
- memcpy(track->vos_data, st->codec->extradata, track->vos_len);
+ if (st->codec->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
+ mov_create_dvd_sub_decoder_specific_info(track, st);
+ else {
+ track->vos_len = st->codec->extradata_size;
+ track->vos_data = av_malloc(track->vos_len);
+ memcpy(track->vos_data, st->codec->extradata, track->vos_len);
+ }
}
}
enable_tracks(s);
- if (mov->mode == MODE_ISM) {
+ if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
/* If no fragmentation options have been set, set a default. */
if (!(mov->flags & (FF_MOV_FLAG_FRAG_KEYFRAME |
FF_MOV_FLAG_FRAG_CUSTOM)) &&
!mov->max_fragment_duration && !mov->max_fragment_size)
- mov->max_fragment_duration = 5000000;
- mov->flags |= FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF |
- FF_MOV_FLAG_FRAGMENT;
- }
-
- if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) {
+ mov->flags |= FF_MOV_FLAG_FRAG_KEYFRAME;
+ } else {
if (mov->flags & FF_MOV_FLAG_FASTSTART)
mov->reserved_moov_pos = avio_tell(pb);
mov_write_mdat_tag(pb, mov);
static int get_moov_size(AVFormatContext *s)
{
int ret;
- uint8_t *buf;
AVIOContext *moov_buf;
MOVMuxContext *mov = s->priv_data;
- if ((ret = avio_open_dyn_buf(&moov_buf)) < 0)
+ if ((ret = ffio_open_null_buf(&moov_buf)) < 0)
return ret;
mov_write_moov_tag(moov_buf, mov, s);
- ret = avio_close_dyn_buf(moov_buf, &buf);
- av_free(buf);
- return ret;
+ return ffio_close_null_buf(moov_buf);
}
/*
.priv_class = &ismv_muxer_class,
};
#endif
+#if CONFIG_F4V_MUXER
+MOV_CLASS(f4v)
+AVOutputFormat ff_f4v_muxer = {
+ .name = "f4v",
+ .long_name = NULL_IF_CONFIG_SMALL("F4V Adobe Flash Video"),
+ .mime_type = "application/f4v",
+ .extensions = "f4v",
+ .priv_data_size = sizeof(MOVMuxContext),
+ .audio_codec = AV_CODEC_ID_AAC,
+ .video_codec = AV_CODEC_ID_H264,
+ .write_header = mov_write_header,
+ .write_packet = mov_write_packet,
+ .write_trailer = mov_write_trailer,
+ .flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE,
+ .codec_tag = (const AVCodecTag* const []){ codec_f4v_tags, 0 },
+ .priv_class = &f4v_muxer_class,
+};
+#endif
projects / ffmpeg / blobdiff