git.sesse.net Git - ffmpeg/blob - libav/avienc.c

   1 /*
   2  * AVI encoder.
   3  * Copyright (c) 2000 Gerard Lantau.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 #include "avformat.h"
  20 #include "avi.h"
  21
  22 /*
  23  * TODO:
  24  *  - fill all fields if non streamed (nb_frames for example)
  25  */
  26
  27 typedef struct AVIIndex {
  28     unsigned char tag[4];
  29     unsigned int flags, pos, len;
  30     struct AVIIndex *next;
  31 } AVIIndex;
  32
  33 typedef struct {
  34     offset_t movi_list, frames_hdr_all, frames_hdr_strm[MAX_STREAMS];
  35     int audio_strm_length[MAX_STREAMS];
  36     AVIIndex *first, *last;
  37 } AVIContext;
  38
  39 offset_t start_tag(ByteIOContext *pb, char *tag)
  40 {
  41     put_tag(pb, tag);
  42     put_le32(pb, 0);
  43     return url_ftell(pb);
  44 }
  45
  46 void end_tag(ByteIOContext *pb, offset_t start)
  47 {
  48     offset_t pos;
  49
  50     pos = url_ftell(pb);
  51     url_fseek(pb, start - 4, SEEK_SET);
  52     put_le32(pb, (UINT32)(pos - start));
  53     url_fseek(pb, pos, SEEK_SET);
  54 }
  55
  56 /* Note: when encoding, the first matching tag is used, so order is
  57    important if multiple tags possible for a given codec. */
  58 CodecTag codec_bmp_tags[] = {
  59     { CODEC_ID_H263, MKTAG('U', '2', '6', '3') },
  60     { CODEC_ID_H263P, MKTAG('U', '2', '6', '3') },
  61     { CODEC_ID_H263I, MKTAG('I', '2', '6', '3') }, /* intel h263 */
  62     { CODEC_ID_MJPEG, MKTAG('M', 'J', 'P', 'G') },
  63     { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') },
  64     { CODEC_ID_MPEG4, MKTAG('d', 'i', 'v', 'x') },
  65     { CODEC_ID_MPEG4, MKTAG(0x04, 0, 0, 0) }, /* some broken avi use this */
  66     { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '3') }, /* default signature when using MSMPEG4 */
  67     { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
  68     { CODEC_ID_MSMPEG4V2, MKTAG('M', 'P', '4', '2') },
  69     { CODEC_ID_MSMPEG4V1, MKTAG('M', 'P', '4', '1') },
  70     { 0, 0 },
  71 };
  72
  73 unsigned int codec_get_tag(const CodecTag *tags, int id)
  74 {
  75     while (tags->id != 0) {
  76         if (tags->id == id)
  77             return tags->tag;
  78         tags++;
  79     }
  80     return 0;
  81 }
  82
  83 int codec_get_id(const CodecTag *tags, unsigned int tag)
  84 {
  85     while (tags->id != 0) {
  86         if (tags->tag == tag)
  87             return tags->id;
  88         tags++;
  89     }
  90     return 0;
  91 }
  92
  93 unsigned int codec_get_bmp_tag(int id)
  94 {
  95     return codec_get_tag(codec_bmp_tags, id);
  96 }
  97
  98 /* BITMAPINFOHEADER header */
  99 void put_bmp_header(ByteIOContext *pb, AVCodecContext *enc, CodecTag *tags)
 100 {
 101     put_le32(pb, 40); /* size */
 102     put_le32(pb, enc->width);
 103     put_le32(pb, enc->height);
 104     put_le16(pb, 1); /* planes */
 105     put_le16(pb, 24); /* depth */
 106     /* compression type */
 107     put_le32(pb, codec_get_tag(tags, enc->codec_id));
 108     put_le32(pb, enc->width * enc->height * 3);
 109     put_le32(pb, 0);
 110     put_le32(pb, 0);
 111     put_le32(pb, 0);
 112     put_le32(pb, 0);
 113 }
 114
 115 void parse_specific_params(AVCodecContext *stream, int *au_byterate, int *au_ssize, int *au_scale)
 116 {
 117     switch(stream->codec_id) {
 118     case CODEC_ID_PCM_S16LE:
 119        *au_scale = *au_ssize = 2*stream->channels;
 120        *au_byterate = *au_ssize * stream->sample_rate;
 121         break;
 122     case CODEC_ID_PCM_U8:
 123     case CODEC_ID_PCM_ALAW:
 124     case CODEC_ID_PCM_MULAW:
 125         *au_scale = *au_ssize = stream->channels;
 126         *au_byterate = *au_ssize * stream->sample_rate;
 127         break;
 128     case CODEC_ID_MP2:
 129         *au_ssize = 1;
 130         *au_scale = 1;
 131         *au_byterate = stream->bit_rate / 8;
 132     case CODEC_ID_MP3LAME:
 133         *au_ssize = 1;
 134         *au_scale = 1;
 135         *au_byterate = stream->bit_rate / 8;
 136     default:
 137         *au_ssize = 1;
 138         *au_scale = 1;
 139         *au_byterate = stream->bit_rate / 8;
 140         break;
 141     }
 142 }
 143
 144 static int avi_write_header(AVFormatContext *s)
 145 {
 146     AVIContext *avi;
 147     ByteIOContext *pb = &s->pb;
 148     int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
 149     AVCodecContext *stream, *video_enc;
 150     offset_t list1, list2, strh, strf;
 151
 152     avi = malloc(sizeof(AVIContext));
 153     if (!avi)
 154         return -1;
 155     memset(avi, 0, sizeof(AVIContext));
 156     s->priv_data = avi;
 157
 158     put_tag(pb, "RIFF");
 159     put_le32(pb, 0); /* file length */
 160     put_tag(pb, "AVI ");
 161
 162     /* header list */
 163     list1 = start_tag(pb, "LIST");
 164     put_tag(pb, "hdrl");
 165
 166     /* avi header */
 167     put_tag(pb, "avih");
 168     put_le32(pb, 14 * 4);
 169     bitrate = 0;
 170
 171     video_enc = NULL;
 172     for(n=0;n<s->nb_streams;n++) {
 173         stream = &s->streams[n]->codec;
 174         bitrate += stream->bit_rate;
 175         if (stream->codec_type == CODEC_TYPE_VIDEO)
 176             video_enc = stream;
 177     }
 178
 179     if (!video_enc) {
 180         free(avi);
 181         return -1;
 182     }
 183     nb_frames = 0;
 184
 185     put_le32(pb, (UINT32)(INT64_C(1000000) * FRAME_RATE_BASE / video_enc->frame_rate));
 186     put_le32(pb, bitrate / 8); /* XXX: not quite exact */
 187     put_le32(pb, 0); /* padding */
 188     put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
 189     avi->frames_hdr_all = url_ftell(pb); /* remember this offset to fill later */
 190     put_le32(pb, nb_frames); /* nb frames, filled later */
 191     put_le32(pb, 0); /* initial frame */
 192     put_le32(pb, s->nb_streams); /* nb streams */
 193     put_le32(pb, 1024 * 1024); /* suggested buffer size */
 194     put_le32(pb, video_enc->width);
 195     put_le32(pb, video_enc->height);
 196     put_le32(pb, 0); /* reserved */
 197     put_le32(pb, 0); /* reserved */
 198     put_le32(pb, 0); /* reserved */
 199     put_le32(pb, 0); /* reserved */
 200
 201     /* stream list */
 202     for(i=0;i<n;i++) {
 203         list2 = start_tag(pb, "LIST");
 204         put_tag(pb, "strl");
 205
 206         stream = &s->streams[i]->codec;
 207
 208         /* stream generic header */
 209         strh = start_tag(pb, "strh");
 210         switch(stream->codec_type) {
 211         case CODEC_TYPE_VIDEO:
 212             put_tag(pb, "vids");
 213             put_le32(pb, codec_get_bmp_tag(stream->codec_id));
 214             put_le32(pb, 0); /* flags */
 215             put_le16(pb, 0); /* priority */
 216             put_le16(pb, 0); /* language */
 217             put_le32(pb, 0); /* initial frame */
 218             put_le32(pb, 1000); /* scale */
 219             put_le32(pb, (1000 * stream->frame_rate) / FRAME_RATE_BASE); /* rate */
 220             put_le32(pb, 0); /* start */
 221             avi->frames_hdr_strm[i] = url_ftell(pb); /* remember this offset to fill later */
 222             put_le32(pb, nb_frames); /* length, XXX: fill later */
 223             put_le32(pb, 1024 * 1024); /* suggested buffer size */
 224             put_le32(pb, -1); /* quality */
 225             put_le32(pb, stream->width * stream->height * 3); /* sample size */
 226             put_le16(pb, 0);
 227             put_le16(pb, 0);
 228             put_le16(pb, stream->width);
 229             put_le16(pb, stream->height);
 230             break;
 231         case CODEC_TYPE_AUDIO:
 232             put_tag(pb, "auds");
 233             put_le32(pb, 1); /* tag */
 234             put_le32(pb, 0); /* flags */
 235             put_le16(pb, 0); /* priority */
 236             put_le16(pb, 0); /* language */
 237             put_le32(pb, 0); /* initial frame */
 238             parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
 239             put_le32(pb, au_scale); /* scale */
 240             put_le32(pb, au_byterate); /* rate */
 241             put_le32(pb, 0); /* start */
 242             avi->frames_hdr_strm[i] = url_ftell(pb); /* remember this offset to fill later */
 243             put_le32(pb, 0); /* length, XXX: filled later */
 244             put_le32(pb, 12 * 1024); /* suggested buffer size */
 245             put_le32(pb, -1); /* quality */
 246             put_le32(pb, au_ssize); /* sample size */
 247             put_le32(pb, 0);
 248             put_le32(pb, 0);
 249             break;
 250         }
 251         end_tag(pb, strh);
 252
 253         strf = start_tag(pb, "strf");
 254         switch(stream->codec_type) {
 255         case CODEC_TYPE_VIDEO:
 256             put_bmp_header(pb, stream, codec_bmp_tags);
 257             break;
 258         case CODEC_TYPE_AUDIO:
 259             if (put_wav_header(pb, stream) < 0) {
 260                 free(avi);
 261                 return -1;
 262             }
 263             break;
 264         }
 265         end_tag(pb, strf);
 266         end_tag(pb, list2);
 267     }
 268
 269     end_tag(pb, list1);
 270
 271     avi->movi_list = start_tag(pb, "LIST");
 272     avi->first = NULL;
 273     avi->last = NULL;
 274     put_tag(pb, "movi");
 275
 276     put_flush_packet(pb);
 277
 278     return 0;
 279 }
 280
 281 static int avi_write_packet(AVFormatContext *s, int stream_index,
 282                             UINT8 *buf, int size, int force_pts)
 283 {
 284     AVIContext *avi = s->priv_data;
 285     ByteIOContext *pb = &s->pb;
 286     AVIIndex *idx;
 287     unsigned char tag[5];
 288     unsigned int flags;
 289     AVCodecContext *enc;
 290
 291     enc = &s->streams[stream_index]->codec;
 292
 293     tag[0] = '0';
 294     tag[1] = '0' + stream_index;
 295     if (enc->codec_type == CODEC_TYPE_VIDEO) {
 296         tag[2] = 'd';
 297         tag[3] = 'c';
 298         flags = enc->key_frame ? 0x10 : 0x00;
 299     } else {
 300         tag[2] = 'w';
 301         tag[3] = 'b';
 302         flags = 0x10;
 303     }
 304     if (enc->codec_type == CODEC_TYPE_AUDIO)
 305        avi->audio_strm_length[stream_index] += size;
 306
 307     if (!url_is_streamed(&s->pb)) {
 308         idx = malloc(sizeof(AVIIndex));
 309         memcpy(idx->tag, tag, 4);
 310         idx->flags = flags;
 311         idx->pos = url_ftell(pb) - avi->movi_list;
 312         idx->len = size;
 313         idx->next = NULL;
 314         if (!avi->last)
 315             avi->first = idx;
 316         else
 317             avi->last->next = idx;
 318         avi->last = idx;
 319     }
 320
 321     put_buffer(pb, tag, 4);
 322     put_le32(pb, size);
 323     put_buffer(pb, buf, size);
 324     if (size & 1)
 325         put_byte(pb, 0);
 326
 327     put_flush_packet(pb);
 328     return 0;
 329 }
 330
 331 static int avi_write_trailer(AVFormatContext *s)
 332 {
 333     ByteIOContext *pb = &s->pb;
 334     AVIContext *avi = s->priv_data;
 335     offset_t file_size, idx_chunk;
 336     int n, nb_frames, au_byterate, au_ssize, au_scale;
 337     AVCodecContext *stream;
 338     AVIIndex *idx;
 339
 340     if (!url_is_streamed(&s->pb)) {
 341         end_tag(pb, avi->movi_list);
 342
 343         idx_chunk = start_tag(pb, "idx1");
 344         idx = avi->first;
 345         while (idx != NULL) {
 346             put_buffer(pb, idx->tag, 4);
 347             put_le32(pb, idx->flags);
 348             put_le32(pb, idx->pos);
 349             put_le32(pb, idx->len);
 350             idx = idx->next;
 351         }
 352         end_tag(pb, idx_chunk);
 353
 354         /* update file size */
 355         file_size = url_ftell(pb);
 356         url_fseek(pb, 4, SEEK_SET);
 357         put_le32(pb, (UINT32)(file_size - 8));
 358
 359         /* Fill in frame/sample counters */
 360         nb_frames = 0;
 361         for(n=0;n<s->nb_streams;n++) {
 362             if (avi->frames_hdr_strm[n] != 0) {
 363                 stream = &s->streams[n]->codec;
 364                 url_fseek(pb, avi->frames_hdr_strm[n], SEEK_SET);
 365                 if (stream->codec_type == CODEC_TYPE_VIDEO) {
 366                     put_le32(pb, stream->frame_number);
 367                     if (nb_frames < stream->frame_number)
 368                         nb_frames = stream->frame_number;
 369                 } else {
 370                     if (stream->codec_id == CODEC_ID_MP2 || stream->codec_id == CODEC_ID_MP3LAME) {
 371                         put_le32(pb, stream->frame_number);
 372                         nb_frames += stream->frame_number;
 373                     } else {
 374                         parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
 375                         put_le32(pb, avi->audio_strm_length[n] / au_ssize);
 376                     }
 377                 }
 378             }
 379        }
 380        if (avi->frames_hdr_all != 0) {
 381            url_fseek(pb, avi->frames_hdr_all, SEEK_SET);
 382            put_le32(pb, nb_frames);
 383        }
 384         url_fseek(pb, file_size, SEEK_SET);
 385     }
 386     put_flush_packet(pb);
 387
 388     free(avi);
 389     return 0;
 390 }
 391
 392 AVFormat avi_format = {
 393     "avi",
 394     "avi format",
 395     "video/x-msvideo",
 396     "avi",
 397     CODEC_ID_MP2,
 398     CODEC_ID_MSMPEG4,
 399     avi_write_header,
 400     avi_write_packet,
 401     avi_write_trailer,
 402
 403     avi_read_header,
 404     avi_read_packet,
 405     avi_read_close,
 406 };