webmenc.c

   1 /*
   2  *  Copyright (c) 2013 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10 #include "webmenc.h"
  11
  12 #include <limits.h>
  13 #include <string.h>
  14
  15 #include "third_party/libmkv/EbmlWriter.h"
  16 #include "third_party/libmkv/EbmlIDs.h"
  17
  18 void Ebml_Write(struct EbmlGlobal *glob,
  19                 const void *buffer_in,
  20                 unsigned long len) {
  21   (void) fwrite(buffer_in, 1, len, glob->stream);
  22 }
  23
  24 #define WRITE_BUFFER(s) \
  25 for (i = len - 1; i >= 0; i--) { \
  26   x = (char)(*(const s *)buffer_in >> (i * CHAR_BIT)); \
  27   Ebml_Write(glob, &x, 1); \
  28 }
  29
  30 void Ebml_Serialize(struct EbmlGlobal *glob,
  31                     const void *buffer_in,
  32                     int buffer_size,
  33                     unsigned long len) {
  34   char x;
  35   int i;
  36
  37   /* buffer_size:
  38    * 1 - int8_t;
  39    * 2 - int16_t;
  40    * 3 - int32_t;
  41    * 4 - int64_t;
  42    */
  43   switch (buffer_size) {
  44     case 1:
  45       WRITE_BUFFER(int8_t)
  46       break;
  47     case 2:
  48       WRITE_BUFFER(int16_t)
  49       break;
  50     case 4:
  51       WRITE_BUFFER(int32_t)
  52       break;
  53     case 8:
  54       WRITE_BUFFER(int64_t)
  55       break;
  56     default:
  57       break;
  58   }
  59 }
  60 #undef WRITE_BUFFER
  61
  62 /* Need a fixed size serializer for the track ID. libmkv provides a 64 bit
  63  * one, but not a 32 bit one.
  64  */
  65 static void Ebml_SerializeUnsigned32(struct EbmlGlobal *glob,
  66                                      unsigned int class_id,
  67                                      uint64_t ui) {
  68   const unsigned char sizeSerialized = 4 | 0x80;
  69   Ebml_WriteID(glob, class_id);
  70   Ebml_Serialize(glob, &sizeSerialized, sizeof(sizeSerialized), 1);
  71   Ebml_Serialize(glob, &ui, sizeof(ui), 4);
  72 }
  73
  74 static void Ebml_StartSubElement(struct EbmlGlobal *glob,
  75                                  EbmlLoc *ebmlLoc,
  76                                  unsigned int class_id) {
  77   const uint64_t kEbmlUnknownLength = LITERALU64(0x01FFFFFF, 0xFFFFFFFF);
  78   Ebml_WriteID(glob, class_id);
  79   *ebmlLoc = ftello(glob->stream);
  80   Ebml_Serialize(glob, &kEbmlUnknownLength, sizeof(kEbmlUnknownLength), 8);
  81 }
  82
  83 static void Ebml_EndSubElement(struct EbmlGlobal *glob, EbmlLoc *ebmlLoc) {
  84   off_t pos;
  85   uint64_t size;
  86
  87   /* Save the current stream pointer. */
  88   pos = ftello(glob->stream);
  89
  90   /* Calculate the size of this element. */
  91   size = pos - *ebmlLoc - 8;
  92   size |= LITERALU64(0x01000000, 0x00000000);
  93
  94   /* Seek back to the beginning of the element and write the new size. */
  95   fseeko(glob->stream, *ebmlLoc, SEEK_SET);
  96   Ebml_Serialize(glob, &size, sizeof(size), 8);
  97
  98   /* Reset the stream pointer. */
  99   fseeko(glob->stream, pos, SEEK_SET);
 100 }
 101
 102 void write_webm_seek_element(struct EbmlGlobal *ebml,
 103                              unsigned int id,
 104                              off_t pos) {
 105   uint64_t offset = pos - ebml->position_reference;
 106   EbmlLoc start;
 107   Ebml_StartSubElement(ebml, &start, Seek);
 108   Ebml_SerializeBinary(ebml, SeekID, id);
 109   Ebml_SerializeUnsigned64(ebml, SeekPosition, offset);
 110   Ebml_EndSubElement(ebml, &start);
 111 }
 112
 113 void write_webm_seek_info(struct EbmlGlobal *ebml) {
 114   off_t pos;
 115   EbmlLoc start;
 116   EbmlLoc startInfo;
 117   uint64_t frame_time;
 118   char version_string[64];
 119
 120   /* Save the current stream pointer. */
 121   pos = ftello(ebml->stream);
 122
 123   if (ebml->seek_info_pos)
 124     fseeko(ebml->stream, ebml->seek_info_pos, SEEK_SET);
 125   else
 126     ebml->seek_info_pos = pos;
 127
 128   Ebml_StartSubElement(ebml, &start, SeekHead);
 129   write_webm_seek_element(ebml, Tracks, ebml->track_pos);
 130   write_webm_seek_element(ebml, Cues, ebml->cue_pos);
 131   write_webm_seek_element(ebml, Info, ebml->segment_info_pos);
 132   Ebml_EndSubElement(ebml, &start);
 133
 134   /* Create and write the Segment Info. */
 135   if (ebml->debug) {
 136     strcpy(version_string, "vpxenc");
 137   } else {
 138     strcpy(version_string, "vpxenc ");
 139     strncat(version_string,
 140             vpx_codec_version_str(),
 141             sizeof(version_string) - 1 - strlen(version_string));
 142   }
 143
 144   frame_time = (uint64_t)1000 * ebml->framerate.den
 145                / ebml->framerate.num;
 146   ebml->segment_info_pos = ftello(ebml->stream);
 147   Ebml_StartSubElement(ebml, &startInfo, Info);
 148   Ebml_SerializeUnsigned(ebml, TimecodeScale, 1000000);
 149   Ebml_SerializeFloat(ebml, Segment_Duration,
 150                       (double)(ebml->last_pts_ms + frame_time));
 151   Ebml_SerializeString(ebml, 0x4D80, version_string);
 152   Ebml_SerializeString(ebml, 0x5741, version_string);
 153   Ebml_EndSubElement(ebml, &startInfo);
 154 }
 155
 156 void write_webm_file_header(struct EbmlGlobal *glob,
 157                             const vpx_codec_enc_cfg_t *cfg,
 158                             const struct vpx_rational *fps,
 159                             stereo_format_t stereo_fmt,
 160                             unsigned int fourcc) {
 161   EbmlLoc start;
 162   EbmlLoc trackStart;
 163   EbmlLoc videoStart;
 164   unsigned int trackNumber = 1;
 165   uint64_t trackID = 0;
 166   unsigned int pixelWidth = cfg->g_w;
 167   unsigned int pixelHeight = cfg->g_h;
 168
 169   /* Write the EBML header. */
 170   Ebml_StartSubElement(glob, &start, EBML);
 171   Ebml_SerializeUnsigned(glob, EBMLVersion, 1);
 172   Ebml_SerializeUnsigned(glob, EBMLReadVersion, 1);
 173   Ebml_SerializeUnsigned(glob, EBMLMaxIDLength, 4);
 174   Ebml_SerializeUnsigned(glob, EBMLMaxSizeLength, 8);
 175   Ebml_SerializeString(glob, DocType, "webm");
 176   Ebml_SerializeUnsigned(glob, DocTypeVersion, 2);
 177   Ebml_SerializeUnsigned(glob, DocTypeReadVersion, 2);
 178   Ebml_EndSubElement(glob, &start);
 179
 180   /* Open and begin writing the segment element. */
 181   Ebml_StartSubElement(glob, &glob->startSegment, Segment);
 182   glob->position_reference = ftello(glob->stream);
 183   glob->framerate = *fps;
 184   write_webm_seek_info(glob);
 185
 186   /* Open and write the Tracks element. */
 187   glob->track_pos = ftello(glob->stream);
 188   Ebml_StartSubElement(glob, &trackStart, Tracks);
 189
 190   /* Open and write the Track entry. */
 191   Ebml_StartSubElement(glob, &start, TrackEntry);
 192   Ebml_SerializeUnsigned(glob, TrackNumber, trackNumber);
 193   glob->track_id_pos = ftello(glob->stream);
 194   Ebml_SerializeUnsigned32(glob, TrackUID, trackID);
 195   Ebml_SerializeUnsigned(glob, TrackType, 1);
 196   Ebml_SerializeString(glob, CodecID,
 197                        fourcc == VP8_FOURCC ? "V_VP8" : "V_VP9");
 198   Ebml_StartSubElement(glob, &videoStart, Video);
 199   Ebml_SerializeUnsigned(glob, PixelWidth, pixelWidth);
 200   Ebml_SerializeUnsigned(glob, PixelHeight, pixelHeight);
 201   Ebml_SerializeUnsigned(glob, StereoMode, stereo_fmt);
 202   Ebml_EndSubElement(glob, &videoStart);
 203
 204   /* Close Track entry. */
 205   Ebml_EndSubElement(glob, &start);
 206
 207   /* Close Tracks element. */
 208   Ebml_EndSubElement(glob, &trackStart);
 209
 210   /* Segment element remains open. */
 211 }
 212
 213 void write_webm_block(struct EbmlGlobal *glob,
 214                       const vpx_codec_enc_cfg_t *cfg,
 215                       const vpx_codec_cx_pkt_t *pkt) {
 216   unsigned int block_length;
 217   unsigned char track_number;
 218   uint16_t block_timecode = 0;
 219   unsigned char flags;
 220   int64_t pts_ms;
 221   int start_cluster = 0, is_keyframe;
 222
 223   /* Calculate the PTS of this frame in milliseconds. */
 224   pts_ms = pkt->data.frame.pts * 1000
 225            * (uint64_t)cfg->g_timebase.num / (uint64_t)cfg->g_timebase.den;
 226
 227   if (pts_ms <= glob->last_pts_ms)
 228     pts_ms = glob->last_pts_ms + 1;
 229
 230   glob->last_pts_ms = pts_ms;
 231
 232   /* Calculate the relative time of this block. */
 233   if (pts_ms - glob->cluster_timecode > SHRT_MAX)
 234     start_cluster = 1;
 235   else
 236     block_timecode = (uint16_t)pts_ms - glob->cluster_timecode;
 237
 238   is_keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY);
 239   if (start_cluster || is_keyframe) {
 240     if (glob->cluster_open)
 241       Ebml_EndSubElement(glob, &glob->startCluster);
 242
 243     /* Open the new cluster. */
 244     block_timecode = 0;
 245     glob->cluster_open = 1;
 246     glob->cluster_timecode = (uint32_t)pts_ms;
 247     glob->cluster_pos = ftello(glob->stream);
 248     Ebml_StartSubElement(glob, &glob->startCluster, Cluster);
 249     Ebml_SerializeUnsigned(glob, Timecode, glob->cluster_timecode);
 250
 251     /* Save a cue point if this is a keyframe. */
 252     if (is_keyframe) {
 253       struct cue_entry *cue, *new_cue_list;
 254
 255       new_cue_list = realloc(glob->cue_list,
 256                              (glob->cues + 1) * sizeof(struct cue_entry));
 257       if (new_cue_list)
 258         glob->cue_list = new_cue_list;
 259       else
 260         fatal("Failed to realloc cue list.");
 261
 262       cue = &glob->cue_list[glob->cues];
 263       cue->time = glob->cluster_timecode;
 264       cue->loc = glob->cluster_pos;
 265       glob->cues++;
 266     }
 267   }
 268
 269   /* Write the Simple Block. */
 270   Ebml_WriteID(glob, SimpleBlock);
 271
 272   block_length = (unsigned int)pkt->data.frame.sz + 4;
 273   block_length |= 0x10000000;
 274   Ebml_Serialize(glob, &block_length, sizeof(block_length), 4);
 275
 276   track_number = 1;
 277   track_number |= 0x80;
 278   Ebml_Write(glob, &track_number, 1);
 279
 280   Ebml_Serialize(glob, &block_timecode, sizeof(block_timecode), 2);
 281
 282   flags = 0;
 283   if (is_keyframe)
 284     flags |= 0x80;
 285   if (pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE)
 286     flags |= 0x08;
 287   Ebml_Write(glob, &flags, 1);
 288
 289   Ebml_Write(glob, pkt->data.frame.buf, (unsigned int)pkt->data.frame.sz);
 290 }
 291
 292 void write_webm_file_footer(struct EbmlGlobal *glob, int hash) {
 293   EbmlLoc start_cues;
 294   EbmlLoc start_cue_point;
 295   EbmlLoc start_cue_tracks;
 296   unsigned int i;
 297
 298   if (glob->cluster_open)
 299     Ebml_EndSubElement(glob, &glob->startCluster);
 300
 301   glob->cue_pos = ftello(glob->stream);
 302   Ebml_StartSubElement(glob, &start_cues, Cues);
 303
 304   for (i = 0; i < glob->cues; i++) {
 305     struct cue_entry *cue = &glob->cue_list[i];
 306     Ebml_StartSubElement(glob, &start_cue_point, CuePoint);
 307     Ebml_SerializeUnsigned(glob, CueTime, cue->time);
 308
 309     Ebml_StartSubElement(glob, &start_cue_tracks, CueTrackPositions);
 310     Ebml_SerializeUnsigned(glob, CueTrack, 1);
 311     Ebml_SerializeUnsigned64(glob, CueClusterPosition,
 312                              cue->loc - glob->position_reference);
 313     Ebml_EndSubElement(glob, &start_cue_tracks);
 314
 315     Ebml_EndSubElement(glob, &start_cue_point);
 316   }
 317
 318   Ebml_EndSubElement(glob, &start_cues);
 319
 320   /* Close the Segment. */
 321   Ebml_EndSubElement(glob, &glob->startSegment);
 322
 323   /* Patch up the seek info block. */
 324   write_webm_seek_info(glob);
 325
 326   /* Patch up the track id. */
 327   fseeko(glob->stream, glob->track_id_pos, SEEK_SET);
 328   Ebml_SerializeUnsigned32(glob, TrackUID, glob->debug ? 0xDEADBEEF : hash);
 329
 330   fseeko(glob->stream, 0, SEEK_END);
 331 }