git.sesse.net Git - vlc/blob - modules/codec/opus_header.c

   1 /* Copyright (C)2012 Xiph.Org Foundation
   2    File: opus_header.c
   3
   4    Redistribution and use in source and binary forms, with or without
   5    modification, are permitted provided that the following conditions
   6    are met:
   7
   8    - Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10
  11    - Redistributions in binary form must reproduce the above copyright
  12    notice, this list of conditions and the following disclaimer in the
  13    documentation and/or other materials provided with the distribution.
  14
  15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  19    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include "opus_header.h"
  33 #include <string.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36
  37 #include <vlc_common.h>
  38 #include "../demux/xiph.h"
  39
  40 /* Header contents:
  41   - "OpusHead" (64 bits)
  42   - version number (8 bits)
  43   - Channels C (8 bits)
  44   - Pre-skip (16 bits)
  45   - Sampling rate (32 bits)
  46   - Gain in dB (16 bits, S7.8)
  47   - Mapping (8 bits, 0=single stream (mono/stereo) 1=Vorbis mapping,
  48              2..254: reserved, 255: multistream with no mapping)
  49
  50   - if (mapping != 0)
  51      - N = totel number of streams (8 bits)
  52      - M = number of paired streams (8 bits)
  53      - C times channel origin
  54           - if (C<2*M)
  55              - stream = byte/2
  56              - if (byte&0x1 == 0)
  57                  - left
  58                else
  59                  - right
  60           - else
  61              - stream = byte-M
  62 */
  63
  64 typedef struct {
  65     unsigned char *data;
  66     int maxlen;
  67     int pos;
  68 } Packet;
  69
  70 typedef struct {
  71     const unsigned char *data;
  72     int maxlen;
  73     int pos;
  74 } ROPacket;
  75
  76 static int write_uint32(Packet *p, uint32_t val)
  77 {
  78     if (p->pos>p->maxlen-4)
  79         return 0;
  80     p->data[p->pos  ] = (val    ) & 0xFF;
  81     p->data[p->pos+1] = (val>> 8) & 0xFF;
  82     p->data[p->pos+2] = (val>>16) & 0xFF;
  83     p->data[p->pos+3] = (val>>24) & 0xFF;
  84     p->pos += 4;
  85     return 1;
  86 }
  87
  88 static int write_uint16(Packet *p, uint16_t val)
  89 {
  90     if (p->pos>p->maxlen-2)
  91         return 0;
  92     p->data[p->pos  ] = (val    ) & 0xFF;
  93     p->data[p->pos+1] = (val>> 8) & 0xFF;
  94     p->pos += 2;
  95     return 1;
  96 }
  97
  98 static int write_chars(Packet *p, const unsigned char *str, int nb_chars)
  99 {
 100     if (p->pos>p->maxlen-nb_chars)
 101         return 0;
 102     for (int i=0;i<nb_chars;i++)
 103         p->data[p->pos++] = str[i];
 104     return 1;
 105 }
 106
 107 static int read_uint32(ROPacket *p, uint32_t *val)
 108 {
 109     if (p->pos>p->maxlen-4)
 110         return 0;
 111     *val =  (uint32_t)p->data[p->pos  ];
 112     *val |= (uint32_t)p->data[p->pos+1]<< 8;
 113     *val |= (uint32_t)p->data[p->pos+2]<<16;
 114     *val |= (uint32_t)p->data[p->pos+3]<<24;
 115     p->pos += 4;
 116     return 1;
 117 }
 118
 119 static int read_uint16(ROPacket *p, uint16_t *val)
 120 {
 121     if (p->pos>p->maxlen-2)
 122         return 0;
 123     *val =  (uint16_t)p->data[p->pos  ];
 124     *val |= (uint16_t)p->data[p->pos+1]<<8;
 125     p->pos += 2;
 126     return 1;
 127 }
 128
 129 static int read_chars(ROPacket *p, unsigned char *str, int nb_chars)
 130 {
 131     if (p->pos>p->maxlen-nb_chars)
 132         return 0;
 133     for (int i=0;i<nb_chars;i++)
 134         str[i] = p->data[p->pos++];
 135     return 1;
 136 }
 137
 138 int opus_header_parse(const unsigned char *packet, int len, OpusHeader *h)
 139 {
 140     char str[9];
 141     ROPacket p;
 142     unsigned char ch;
 143     uint16_t shortval;
 144
 145     p.data = packet;
 146     p.maxlen = len;
 147     p.pos = 0;
 148     str[8] = 0;
 149     if (len<19)return 0;
 150     read_chars(&p, (unsigned char*)str, 8);
 151     if (memcmp(str, "OpusHead", 8)!=0)
 152         return 0;
 153
 154     if (!read_chars(&p, &ch, 1))
 155         return 0;
 156     h->version = ch;
 157     if((h->version&240) != 0) /* Only major version 0 supported. */
 158         return 0;
 159
 160     if (!read_chars(&p, &ch, 1))
 161         return 0;
 162     h->channels = ch;
 163     if (h->channels == 0)
 164         return 0;
 165
 166     if (!read_uint16(&p, &shortval))
 167         return 0;
 168     h->preskip = shortval;
 169
 170     if (!read_uint32(&p, &h->input_sample_rate))
 171         return 0;
 172
 173     if (!read_uint16(&p, &shortval))
 174         return 0;
 175     h->gain = (short)shortval;
 176
 177     if (!read_chars(&p, &ch, 1))
 178         return 0;
 179     h->channel_mapping = ch;
 180
 181     if (h->channel_mapping != 0)
 182     {
 183         if (!read_chars(&p, &ch, 1))
 184             return 0;
 185
 186         if (ch<1)
 187             return 0;
 188         h->nb_streams = ch;
 189
 190         if (!read_chars(&p, &ch, 1))
 191             return 0;
 192
 193         if (ch>h->nb_streams || (ch+h->nb_streams)>255)
 194             return 0;
 195         h->nb_coupled = ch;
 196
 197         /* Multi-stream support */
 198         for (int i=0;i<h->channels;i++)
 199         {
 200             if (!read_chars(&p, &h->stream_map[i], 1))
 201                 return 0;
 202             if (h->stream_map[i]>(h->nb_streams+h->nb_coupled) && h->stream_map[i]!=255)
 203                 return 0;
 204         }
 205     } else {
 206         if(h->channels>2)
 207             return 0;
 208         h->nb_streams = 1;
 209         h->nb_coupled = h->channels>1;
 210         h->stream_map[0]=0;
 211         h->stream_map[1]=1;
 212     }
 213     /*For version 0/1 we know there won't be any more data
 214       so reject any that have data past the end.*/
 215     if ((h->version==0 || h->version==1) && p.pos != len)
 216         return 0;
 217     return 1;
 218 }
 219
 220 /*
 221  Comments will be stored in the Vorbis style.
 222  It is described in the "Structure" section of
 223     http://www.xiph.org/ogg/vorbis/doc/v-comment.html
 224
 225  However, Opus and other non-vorbis formats omit the "framing_bit".
 226
 227 The comment header is decoded as follows:
 228   1) [vendor_length] = unsigned little endian 32 bits integer
 229   2) [vendor_string] = UTF-8 vector as [vendor_length] octets
 230   3) [user_comment_list_length] = unsigned little endian 32 bits integer
 231   4) iterate [user_comment_list_length] times {
 232      5) [length] = unsigned little endian 32 bits integer
 233      6) this iteration's user comment = UTF-8 vector as [length] octets
 234   }
 235   7) done.
 236 */
 237
 238 static char *comment_init(size_t *length, const char *vendor)
 239 {
 240     /*The 'vendor' field should be the actual encoding library used.*/
 241     if (!vendor)
 242         vendor = "unknown";
 243     int vendor_length = strlen(vendor);
 244
 245     int user_comment_list_length = 0;
 246     int len = 8 + 4 + vendor_length + 4;
 247     char *p = malloc(len);
 248     if (p == NULL)
 249         return NULL;
 250
 251     memcpy(p, "OpusTags", 8);
 252     SetDWLE(p + 8, vendor_length);
 253     memcpy(p + 12, vendor, vendor_length);
 254     SetDWLE(p + 12 + vendor_length, user_comment_list_length);
 255
 256     *length = len;
 257     return p;
 258 }
 259
 260 static int comment_add(char **comments, size_t *length, const char *tag,
 261                        const char *val)
 262 {
 263     char *p = *comments;
 264     int vendor_length = GetDWLE(p + 8);
 265     size_t user_comment_list_length = GetDWLE(p + 8 + 4 + vendor_length);
 266     size_t tag_len = (tag ? strlen(tag) : 0);
 267     size_t val_len = strlen(val);
 268     size_t len = (*length) + 4 + tag_len + val_len;
 269
 270     p = realloc(p, len);
 271     if (p == NULL)
 272         return 1;
 273
 274     SetDWLE(p + *length, tag_len + val_len);          /* length of comment */
 275     if (tag) memcpy(p + *length + 4, tag, tag_len);         /* comment */
 276     memcpy(p + *length + 4 + tag_len, val, val_len);        /* comment */
 277     SetDWLE(p + 8 + 4 + vendor_length, user_comment_list_length + 1);
 278     *comments = p;
 279     *length = len;
 280     return 0;
 281 }
 282
 283 /* adds padding so that metadata can be updated without rewriting the whole file */
 284 static int comment_pad(char **comments, size_t *length)
 285 {
 286     const unsigned padding = 512; /* default from opus-tools */
 287
 288     char *p = *comments;
 289     /* Make sure there is at least "padding" worth of padding free, and
 290        round up to the maximum that fits in the current ogg segments. */
 291     size_t newlen = ((*length + padding) / 255 + 1) * 255 - 1;
 292     p = realloc(p, newlen);
 293     if (p == NULL)
 294         return 1;
 295
 296     memset(p + *length, 0, newlen - *length);
 297     *comments = p;
 298     *length = newlen;
 299     return 0;
 300 }
 301
 302 void opus_prepare_header(unsigned channels, unsigned rate, OpusHeader *header)
 303 {
 304     header->version = 1;
 305     header->channels = channels;
 306     header->nb_streams = header->channels;
 307     header->nb_coupled = 0;
 308     header->input_sample_rate = rate;
 309     header->gain = 0; // 0dB
 310     header->channel_mapping = header->channels > 8 ? 255 :
 311                               header->channels > 2;
 312 }
 313
 314 static int opus_header_to_packet(const OpusHeader *h, unsigned char *packet, int len)
 315 {
 316     Packet p;
 317     unsigned char ch;
 318
 319     p.data = packet;
 320     p.maxlen = len;
 321     p.pos = 0;
 322     if (len<19)return 0;
 323     if (!write_chars(&p, (const unsigned char*)"OpusHead", 8))
 324         return 0;
 325     /* Version is 1 */
 326     ch = 1;
 327     if (!write_chars(&p, &ch, 1))
 328         return 0;
 329
 330     ch = h->channels;
 331     if (!write_chars(&p, &ch, 1))
 332         return 0;
 333
 334     if (!write_uint16(&p, h->preskip))
 335         return 0;
 336
 337     if (!write_uint32(&p, h->input_sample_rate))
 338         return 0;
 339
 340     if (!write_uint16(&p, h->gain))
 341         return 0;
 342
 343     ch = h->channel_mapping;
 344     if (!write_chars(&p, &ch, 1))
 345         return 0;
 346
 347     if (h->channel_mapping != 0)
 348     {
 349         ch = h->nb_streams;
 350         if (!write_chars(&p, &ch, 1))
 351             return 0;
 352
 353         ch = h->nb_coupled;
 354         if (!write_chars(&p, &ch, 1))
 355             return 0;
 356
 357         /* Multi-stream support */
 358         for (int i=0;i<h->channels;i++)
 359         {
 360             if (!write_chars(&p, &h->stream_map[i], 1))
 361                 return 0;
 362         }
 363     }
 364
 365     return p.pos;
 366 }
 367
 368 int opus_write_header(uint8_t **p_extra, int *i_extra, OpusHeader *header, const char *vendor)
 369 {
 370     unsigned char header_data[100];
 371     const int packet_size = opus_header_to_packet(header, header_data,
 372                                                   sizeof(header_data));
 373
 374     unsigned char *data[2];
 375     size_t size[2];
 376
 377     data[0] = header_data;
 378     size[0] = packet_size;
 379
 380     size_t comments_length;
 381     char *comments = comment_init(&comments_length, vendor);
 382     if (!comments)
 383         return 1;
 384     if (comment_add(&comments, &comments_length, "ENCODER=",
 385                     "VLC media player"))
 386     {
 387         free(comments);
 388         return 1;
 389     }
 390
 391     if (comment_pad(&comments, &comments_length))
 392     {
 393         free(comments);
 394         return 1;
 395     }
 396
 397     data[1] = (unsigned char *) comments;
 398     size[1] = comments_length;
 399
 400     for (unsigned i = 0; i < ARRAY_SIZE(data); ++i)
 401         if (xiph_AppendHeaders(i_extra, (void **) p_extra, size[i], data[i]))
 402         {
 403             *i_extra = 0;
 404             *p_extra = NULL;
 405         }
 406
 407     return 0;
 408 }
 409