set bits_per_coded_sample for rawvideo
[ffmpeg.git] / libavformat / movenc.c
index 525e81a..bb5fbe2 100644 (file)
@@ -2,6 +2,7 @@
  * MOV, 3GP, MP4 muxer
  * Copyright (c) 2003 Thomas Raivio
  * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>
+ * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
  *
  * This file is part of FFmpeg.
  *
@@ -19,6 +20,7 @@
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
+
 #include "avformat.h"
 #include "riff.h"
 #include "avio.h"
@@ -72,15 +74,15 @@ typedef struct MOVIndex {
     int         height; ///< active picture (w/o VBI) height for D-10/IMX
 } MOVTrack;
 
-typedef struct MOVContext {
+typedef struct MOVMuxContext {
     int     mode;
     int64_t time;
     int     nb_streams;
     int64_t mdat_pos;
     uint64_t mdat_size;
     long    timescale;
-    MOVTrack tracks[MAX_STREAMS];
-} MOVContext;
+    MOVTrack *tracks;
+} MOVMuxContext;
 
 //FIXME support 64 bit variant with wide placeholders
 static int64_t updateSize(ByteIOContext *pb, int64_t pos)
@@ -555,12 +557,16 @@ static const AVCodecTag codec_3gp_tags[] = {
     { CODEC_ID_NONE, 0 },
 };
 
-static const AVCodecTag mov_pix_fmt_tags[] = {
-    { PIX_FMT_YUYV422, MKTAG('y','u','v','s') },
-    { PIX_FMT_UYVY422, MKTAG('2','v','u','y') },
-    { PIX_FMT_BGR555,  MKTAG('r','a','w',' ') },
-    { PIX_FMT_RGB24,   MKTAG('r','a','w',' ') },
-    { PIX_FMT_BGR32_1, MKTAG('r','a','w',' ') },
+static const struct {
+    enum PixelFormat pix_fmt;
+    uint32_t tag;
+    unsigned bps;
+} mov_pix_fmt_tags[] = {
+    { PIX_FMT_YUYV422, MKTAG('y','u','v','s'),  0 },
+    { PIX_FMT_UYVY422, MKTAG('2','v','u','y'),  0 },
+    { PIX_FMT_BGR555,  MKTAG('r','a','w',' '), 16 },
+    { PIX_FMT_RGB24,   MKTAG('r','a','w',' '), 24 },
+    { PIX_FMT_BGR32_1, MKTAG('r','a','w',' '), 32 },
 };
 
 static const AVCodecTag codec_ipod_tags[] = {
@@ -570,6 +576,7 @@ static const AVCodecTag codec_ipod_tags[] = {
     { CODEC_ID_ALAC,   MKTAG('a','l','a','c') },
     { CODEC_ID_AC3,    MKTAG('a','c','-','3') },
     { CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
+    { CODEC_ID_MOV_TEXT, MKTAG('t','e','x','t') },
     { CODEC_ID_NONE, 0 },
 };
 
@@ -586,7 +593,12 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
         else if (track->enc->codec_type == CODEC_TYPE_VIDEO) tag = MKTAG('m','p','4','v');
         else if (track->enc->codec_type == CODEC_TYPE_AUDIO) tag = MKTAG('m','p','4','a');
     } else if (track->mode == MODE_IPOD) {
-        tag = codec_get_tag(codec_ipod_tags, track->enc->codec_id);
+        if (track->enc->codec_type == CODEC_TYPE_SUBTITLE &&
+            (tag == MKTAG('t','x','3','g') ||
+             tag == MKTAG('t','e','x','t')))
+            track->tag = tag; // keep original tag
+        else
+            tag = codec_get_tag(codec_ipod_tags, track->enc->codec_id);
         if (!match_ext(s->filename, "m4a") && !match_ext(s->filename, "m4v"))
             av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a nor .m4v "
                    "Quicktime/Ipod might not play the file\n");
@@ -594,7 +606,8 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
         tag = codec_get_tag(codec_3gp_tags, track->enc->codec_id);
     } else if (!tag || (track->enc->strict_std_compliance >= FF_COMPLIANCE_NORMAL &&
                         (tag == MKTAG('d','v','c','p') ||
-                         track->enc->codec_id == CODEC_ID_RAWVIDEO))) {
+                         track->enc->codec_id == CODEC_ID_RAWVIDEO ||
+                         av_get_bits_per_sample(track->enc->codec_id)))) { // pcm audio
         if (track->enc->codec_id == CODEC_ID_DVVIDEO) {
             if (track->enc->height == 480) /* NTSC */
                 if  (track->enc->pix_fmt == PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');
@@ -603,7 +616,14 @@ static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
             else if (track->enc->pix_fmt == PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');
             else                                             tag = MKTAG('d','v','p','p');
         } else if (track->enc->codec_id == CODEC_ID_RAWVIDEO) {
-            tag = codec_get_tag(mov_pix_fmt_tags, track->enc->pix_fmt);
+            int i;
+            for (i = 0; i < FF_ARRAY_ELEMS(mov_pix_fmt_tags); i++) {
+                if (track->enc->pix_fmt == mov_pix_fmt_tags[i].pix_fmt) {
+                    tag = mov_pix_fmt_tags[i].tag;
+                    track->enc->bits_per_coded_sample = mov_pix_fmt_tags[i].bps;
+                    break;
+                }
+            }
             if (!tag) // restore tag
                 tag = track->enc->codec_tag;
         } else {
@@ -922,8 +942,8 @@ static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack *track)
             hdlr_type = "soun";
             descr = "SoundHandler";
         } else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
-            if (track->mode == MODE_IPOD) hdlr_type = "sbtl";
-            else                          hdlr_type = "text";
+            if (track->tag == MKTAG('t','x','3','g')) hdlr_type = "sbtl";
+            else                                      hdlr_type = "text";
             descr = "SubtitleHandler";
         }
     }
@@ -951,8 +971,8 @@ static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack *track)
     else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
         mov_write_smhd_tag(pb);
     else if (track->enc->codec_type == CODEC_TYPE_SUBTITLE) {
-        if (track->mode == MODE_MOV) mov_write_gmhd_tag(pb);
-        else                         mov_write_nmhd_tag(pb);
+        if (track->tag == MKTAG('t','e','x','t')) mov_write_gmhd_tag(pb);
+        else                                      mov_write_nmhd_tag(pb);
     }
     if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
         mov_write_hdlr_tag(pb, NULL);
@@ -1111,7 +1131,7 @@ static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack *track, AVStream *st)
 
 #if 0
 /* TODO: Not sorted out, but not necessary either */
-static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)
+static int mov_write_iods_tag(ByteIOContext *pb, MOVMuxContext *mov)
 {
     put_be32(pb, 0x15); /* size */
     put_tag(pb, "iods");
@@ -1125,7 +1145,7 @@ static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)
 }
 #endif
 
-static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)
+static int mov_write_mvhd_tag(ByteIOContext *pb, MOVMuxContext *mov)
 {
     int maxTrackID = 1, i;
     int64_t maxTrackLenTemp, maxTrackLen = 0;
@@ -1183,7 +1203,7 @@ static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)
     return 0x6c;
 }
 
-static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVMuxContext *mov,
                                      AVFormatContext *s)
 {
     int64_t pos = url_ftell(pb);
@@ -1200,7 +1220,7 @@ static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVContext *mov,
 }
 
 /* helper function to write a data tag with the specified string as data */
-static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int long_style)
+static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int lang, int long_style)
 {
     if(long_style){
         int64_t pos = url_ftell(pb);
@@ -1212,19 +1232,19 @@ static int mov_write_string_data_tag(ByteIOContext *pb, const char *data, int lo
         return updateSize(pb, pos);
     }else{
         put_be16(pb, strlen(data)); /* string length */
-        put_be16(pb, 0);
+        put_be16(pb, lang);
         put_buffer(pb, data, strlen(data));
         return strlen(data) + 4;
     }
 }
 
-static int mov_write_string_tag(ByteIOContext *pb, const char *name, const char *value, int long_style){
+static int mov_write_string_tag(ByteIOContext *pb, const char *name, const char *value, int lang, int long_style){
     int size = 0;
     if (value && value[0]) {
         int64_t pos = url_ftell(pb);
         put_be32(pb, 0); /* size */
         put_tag(pb, name);
-        mov_write_string_data_tag(pb, value, long_style);
+        mov_write_string_data_tag(pb, value, lang, long_style);
         size= updateSize(pb, pos);
     }
     return size;
@@ -1234,16 +1254,28 @@ static int mov_write_string_metadata(AVFormatContext *s, ByteIOContext *pb,
                                      const char *name, const char *tag,
                                      int long_style)
 {
-    AVMetadataTag *t;
+    int l, lang = 0, len, len2;
+    AVMetadataTag *t, *t2 = NULL;
+    char tag2[16];
 
     if (!(t = av_metadata_get(s->metadata, tag, NULL, 0)))
         return 0;
 
-    return mov_write_string_tag(pb, name, t->value, long_style);
+    len = strlen(t->key);
+    snprintf(tag2, sizeof(tag2), "%s-", tag);
+    while ((t2 = av_metadata_get(s->metadata, tag2, t2, AV_METADATA_IGNORE_SUFFIX))) {
+        len2 = strlen(t2->key);
+        if (len2 == len+4 && !strcmp(t->value, t2->value)
+            && (l=ff_mov_iso639_to_lang(&t2->key[len2-3], 0)) >= 0) {
+            lang = l;
+            break;
+        }
+    }
+    return mov_write_string_tag(pb, name, t->value, lang, long_style);
 }
 
 /* iTunes track number */
-static int mov_write_trkn_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_trkn_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
     AVMetadataTag *t = av_metadata_get(s->metadata, "track", NULL, 0);
@@ -1270,7 +1302,7 @@ static int mov_write_trkn_tag(ByteIOContext *pb, MOVContext *mov,
 }
 
 /* iTunes meta data list */
-static int mov_write_ilst_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_ilst_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
     int64_t pos = url_ftell(pb);
@@ -1281,7 +1313,7 @@ static int mov_write_ilst_tag(ByteIOContext *pb, MOVContext *mov,
     mov_write_string_metadata(s, pb, "\251wrt", "author"   , 1);
     mov_write_string_metadata(s, pb, "\251alb", "album"    , 1);
     mov_write_string_metadata(s, pb, "\251day", "year"     , 1);
-    mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 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);
@@ -1290,18 +1322,17 @@ static int mov_write_ilst_tag(ByteIOContext *pb, MOVContext *mov,
 }
 
 /* iTunes meta data tag */
-static int mov_write_meta_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_meta_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
     int size = 0;
-
-        int64_t pos = url_ftell(pb);
-        put_be32(pb, 0); /* size */
-        put_tag(pb, "meta");
-        put_be32(pb, 0);
-        mov_write_itunes_hdlr_tag(pb, mov, s);
-        mov_write_ilst_tag(pb, mov, s);
-        size = updateSize(pb, pos);
+    int64_t pos = url_ftell(pb);
+    put_be32(pb, 0); /* size */
+    put_tag(pb, "meta");
+    put_be32(pb, 0);
+    mov_write_itunes_hdlr_tag(pb, mov, s);
+    mov_write_ilst_tag(pb, mov, s);
+    size = updateSize(pb, pos);
     return size;
 }
 
@@ -1354,7 +1385,7 @@ static int mov_write_3gp_udta_tag(ByteIOContext *pb, AVFormatContext *s,
     return updateSize(pb, pos);
 }
 
-static int mov_write_udta_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_udta_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
     ByteIOContext *pb_buf;
@@ -1383,7 +1414,7 @@ static int mov_write_udta_tag(ByteIOContext *pb, MOVContext *mov,
             mov_write_string_metadata(s, pb_buf, "\251aut", "author"     , 0);
             mov_write_string_metadata(s, pb_buf, "\251alb", "album"      , 0);
             mov_write_string_metadata(s, pb_buf, "\251day", "year"       , 0);
-            mov_write_string_tag(pb_buf, "\251enc", LIBAVFORMAT_IDENT, 0);
+            mov_write_string_tag(pb_buf, "\251enc", LIBAVFORMAT_IDENT, 0, 0);
             mov_write_string_metadata(s, pb_buf, "\251des", "comment"    , 0);
             mov_write_string_metadata(s, pb_buf, "\251gen", "genre"      , 0);
             mov_write_string_metadata(s, pb_buf, "\251cpy", "copyright"  , 0);
@@ -1453,7 +1484,7 @@ static int mov_write_uuidusmt_tag(ByteIOContext *pb, AVFormatContext *s)
     return 0;
 }
 
-static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov,
+static int mov_write_moov_tag(ByteIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
     int i;
@@ -1485,7 +1516,7 @@ static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov,
     return updateSize(pb, pos);
 }
 
-static int mov_write_mdat_tag(ByteIOContext *pb, MOVContext *mov)
+static int mov_write_mdat_tag(ByteIOContext *pb, MOVMuxContext *mov)
 {
     put_be32(pb, 8);    // placeholder for extended size field (64 bit)
     put_tag(pb, mov->mode == MODE_MOV ? "wide" : "free");
@@ -1499,7 +1530,7 @@ static int mov_write_mdat_tag(ByteIOContext *pb, MOVContext *mov)
 /* TODO: This needs to be more general */
 static int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
 {
-    MOVContext *mov = s->priv_data;
+    MOVMuxContext *mov = s->priv_data;
     int64_t pos = url_ftell(pb);
     int has_h264 = 0, has_video = 0;
     int minor = 0x200;
@@ -1617,7 +1648,7 @@ static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
 static int mov_write_header(AVFormatContext *s)
 {
     ByteIOContext *pb = s->pb;
-    MOVContext *mov = s->priv_data;
+    MOVMuxContext *mov = s->priv_data;
     int i;
 
     if (url_is_streamed(s->pb)) {
@@ -1645,6 +1676,10 @@ static int mov_write_header(AVFormatContext *s)
         }
     }
 
+    mov->tracks = av_mallocz(s->nb_streams*sizeof(*mov->tracks));
+    if (!mov->tracks)
+        return AVERROR(ENOMEM);
+
     for(i=0; i<s->nb_streams; i++){
         AVStream *st= s->streams[i];
         MOVTrack *track= &mov->tracks[i];
@@ -1652,12 +1687,14 @@ static int mov_write_header(AVFormatContext *s)
 
         track->enc = st->codec;
         track->language = ff_mov_iso639_to_lang(lang?lang->value:"und", mov->mode!=MODE_MOV);
+        if (track->language < 0)
+            track->language = 0;
         track->mode = mov->mode;
         track->tag = mov_find_codec_tag(s, track);
         if (!track->tag) {
             av_log(s, AV_LOG_ERROR, "track %d: could not find tag, "
                    "codec not currently supported in container\n", i);
-            return -1;
+            goto error;
         }
         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
             if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||
@@ -1665,11 +1702,10 @@ static int mov_write_header(AVFormatContext *s)
                 track->tag == MKTAG('m','x','5','p') || track->tag == MKTAG('m','x','5','n')) {
                 if (st->codec->width != 720 || (st->codec->height != 608 && st->codec->height != 512)) {
                     av_log(s, AV_LOG_ERROR, "D-10/IMX must use 720x608 or 720x512 video resolution\n");
-                    return -1;
+                    goto error;
                 }
                 track->height = track->tag>>24 == 'n' ? 486 : 576;
-            } else
-                track->height = st->codec->height;
+            }
             track->timescale = st->codec->time_base.den;
             av_set_pts_info(st, 64, 1, st->codec->time_base.den);
             if (track->mode == MODE_MOV && track->timescale > 100000)
@@ -1682,7 +1718,7 @@ static int mov_write_header(AVFormatContext *s)
             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
             if(!st->codec->frame_size && !av_get_bits_per_sample(st->codec->codec_id)) {
                 av_log(s, AV_LOG_ERROR, "track %d: codec frame size is not set\n", i);
-                return -1;
+                goto error;
             }else if(st->codec->frame_size > 1){ /* assume compressed audio */
                 track->audio_vbr = 1;
             }else{
@@ -1693,12 +1729,14 @@ static int mov_write_header(AVFormatContext *s)
                track->enc->codec_id == CODEC_ID_MP3 && track->enc->sample_rate < 16000){
                 av_log(s, AV_LOG_ERROR, "track %d: muxing mp3 at %dhz is not supported\n",
                        i, track->enc->sample_rate);
-                return -1;
+                goto error;
             }
         }else if(st->codec->codec_type == CODEC_TYPE_SUBTITLE){
             track->timescale = st->codec->time_base.den;
             av_set_pts_info(st, 64, 1, st->codec->time_base.den);
         }
+        if (!track->height)
+            track->height = st->codec->height;
     }
 
     mov_write_mdat_tag(pb, mov);
@@ -1708,11 +1746,14 @@ static int mov_write_header(AVFormatContext *s)
     put_flush_packet(pb);
 
     return 0;
+ error:
+    av_freep(&mov->tracks);
+    return -1;
 }
 
 static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
-    MOVContext *mov = s->priv_data;
+    MOVMuxContext *mov = s->priv_data;
     ByteIOContext *pb = s->pb;
     MOVTrack *trk = &mov->tracks[pkt->stream_index];
     AVCodecContext *enc = trk->enc;
@@ -1799,7 +1840,7 @@ static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
 
 static int mov_write_trailer(AVFormatContext *s)
 {
-    MOVContext *mov = s->priv_data;
+    MOVMuxContext *mov = s->priv_data;
     ByteIOContext *pb = s->pb;
     int res = 0;
     int i;
@@ -1830,6 +1871,8 @@ static int mov_write_trailer(AVFormatContext *s)
 
     put_flush_packet(pb);
 
+    av_freep(&mov->tracks);
+
     return res;
 }
 
@@ -1839,7 +1882,7 @@ AVOutputFormat mov_muxer = {
     NULL_IF_CONFIG_SMALL("MOV format"),
     NULL,
     "mov",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_MPEG4,
     mov_write_header,
@@ -1855,7 +1898,7 @@ AVOutputFormat tgp_muxer = {
     NULL_IF_CONFIG_SMALL("3GP format"),
     NULL,
     "3gp",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AMR_NB,
     CODEC_ID_H263,
     mov_write_header,
@@ -1871,7 +1914,7 @@ AVOutputFormat mp4_muxer = {
     NULL_IF_CONFIG_SMALL("MP4 format"),
     "application/mp4",
     "mp4",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_MPEG4,
     mov_write_header,
@@ -1887,7 +1930,7 @@ AVOutputFormat psp_muxer = {
     NULL_IF_CONFIG_SMALL("PSP MP4 format"),
     NULL,
     "mp4,psp",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_MPEG4,
     mov_write_header,
@@ -1903,7 +1946,7 @@ AVOutputFormat tg2_muxer = {
     NULL_IF_CONFIG_SMALL("3GP2 format"),
     NULL,
     "3g2",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AMR_NB,
     CODEC_ID_H263,
     mov_write_header,
@@ -1919,13 +1962,13 @@ AVOutputFormat ipod_muxer = {
     NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
     "application/mp4",
     "m4v,m4a",
-    sizeof(MOVContext),
+    sizeof(MOVMuxContext),
     CODEC_ID_AAC,
     CODEC_ID_H264,
     mov_write_header,
     mov_write_packet,
     mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
-    .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
+    .codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},
 };
 #endif