libhb/nal_units.c

   1 /* nal_units.c
   2  *
   3  * Copyright (c) 2003-2015 HandBrake Team
   4  * This file is part of the HandBrake source code.
   5  * Homepage: <http://handbrake.fr/>.
   6  * It may be used under the terms of the GNU General Public License v2.
   7  * For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
   8  */
   9
  10 #include <stdint.h>
  11 #include <string.h>
  12
  13 #include "common.h"
  14 #include "nal_units.h"
  15
  16 static const uint8_t hb_annexb_startcode[] = { 0x00, 0x00, 0x00, 0x01, };
  17
  18 size_t hb_nal_unit_write_annexb(uint8_t *buf,
  19                                 const uint8_t *nal_unit,
  20                                 const size_t nal_unit_size)
  21 {
  22     if (buf != NULL)
  23     {
  24         memcpy(buf, hb_annexb_startcode, sizeof(hb_annexb_startcode));
  25         memcpy(buf + sizeof(hb_annexb_startcode), nal_unit, nal_unit_size);
  26     }
  27
  28     return sizeof(hb_annexb_startcode) + nal_unit_size;
  29 }
  30
  31 size_t hb_nal_unit_write_isomp4(uint8_t *buf,
  32                                 const uint8_t *nal_unit,
  33                                 const size_t nal_unit_size)
  34 {
  35     int i;
  36     uint8_t length[4]; // 4-byte length replaces Annex B start code prefix
  37
  38     if (buf != NULL)
  39     {
  40         for (i = 0; i < sizeof(length); i++)
  41         {
  42             length[i] = (nal_unit_size >> (8 * (sizeof(length) - 1 - i))) & 0xff;
  43         }
  44
  45         memcpy(buf, &length[0], sizeof(length));
  46         memcpy(buf + sizeof(length), nal_unit, nal_unit_size);
  47     }
  48
  49     return sizeof(length) + nal_unit_size;
  50 }
  51
  52 uint8_t* hb_annexb_find_next_nalu(const uint8_t *start, size_t *size)
  53 {
  54     uint8_t *nal = NULL;
  55     uint8_t *buf = (uint8_t*)start;
  56     uint8_t *end = (uint8_t*)start + *size;
  57
  58     /* Look for an Annex B start code prefix (3-byte sequence == 1) */
  59     while (end - buf > 3)
  60     {
  61         if (!buf[0] && !buf[1] && buf[2] == 1)
  62         {
  63             nal = (buf += 3); // NAL unit begins after start code
  64             break;
  65         }
  66         buf++;
  67     }
  68
  69     if (nal == NULL)
  70     {
  71         *size = 0;
  72         return NULL;
  73     }
  74
  75     /*
  76      * Start code prefix found, look for the next one to determine the size
  77      *
  78      * A 4-byte sequence == 1 is also a start code, so check for a 3-byte
  79      * sequence == 0 too (start code emulation prevention will prevent such a
  80      * sequence from occurring outside of a start code prefix)
  81      */
  82     while (end - buf > 3)
  83     {
  84         if (!buf[0] && !buf[1] && (!buf[2] || buf[2] == 1))
  85         {
  86             end = buf;
  87             break;
  88         }
  89         buf++;
  90     }
  91
  92     *size = end - nal;
  93     return  nal;
  94 }
  95
  96 hb_buffer_t* hb_nal_bitstream_annexb_to_mp4(const uint8_t *data,
  97                                             const size_t size)
  98 {
  99     hb_buffer_t *out;
 100     uint8_t *buf, *end;
 101     size_t out_size, buf_size;
 102
 103     out_size = 0;
 104     buf_size = size;
 105     buf      = (uint8_t*)data;
 106     end      = (uint8_t*)data + size;
 107
 108     while ((buf = hb_annexb_find_next_nalu(buf, &buf_size)) != NULL)
 109     {
 110         out_size += hb_nal_unit_write_isomp4(NULL, buf, buf_size);
 111         buf_size  = end - buf;
 112     }
 113
 114     out = hb_buffer_init(out_size);
 115     if (out == NULL)
 116     {
 117         hb_error("hb_nal_bitstream_annexb_to_mp4: hb_buffer_init failed");
 118         return NULL;
 119     }
 120
 121     out_size = 0;
 122     buf_size = size;
 123     buf      = (uint8_t*)data;
 124     end      = (uint8_t*)data + size;
 125
 126     while ((buf = hb_annexb_find_next_nalu(buf, &buf_size)) != NULL)
 127     {
 128         out_size += hb_nal_unit_write_isomp4(out->data + out_size, buf, buf_size);
 129         buf_size  = end - buf;
 130     }
 131
 132     return out;
 133 }
 134
 135 static size_t mp4_nal_unit_length(const uint8_t *data,
 136                                   const size_t nal_length_size,
 137                                   size_t *nal_unit_length)
 138 {
 139     uint8_t i;
 140
 141     /* In MP4, NAL units are preceded by a 2-4 byte length field */
 142     for (i = 0, *nal_unit_length = 0; i < nal_length_size; i++)
 143     {
 144         *nal_unit_length |= data[i] << (8 * (nal_length_size - 1 - i));
 145     }
 146
 147     return nal_length_size;
 148 }
 149
 150 hb_buffer_t* hb_nal_bitstream_mp4_to_annexb(const uint8_t *data,
 151                                             const size_t size,
 152                                             const uint8_t nal_length_size)
 153 {
 154     hb_buffer_t *out;
 155     uint8_t *buf, *end;
 156     size_t out_size, nal_size;
 157
 158     out_size = 0;
 159     buf      = (uint8_t*)data;
 160     end      = (uint8_t*)data + size;
 161
 162     while (end - buf > nal_length_size)
 163     {
 164         buf += mp4_nal_unit_length(buf, nal_length_size, &nal_size);
 165         if (end - buf < nal_size)
 166         {
 167             hb_log("hb_nal_bitstream_mp4_to_annexb: truncated bitstream"
 168                    " (remaining: %lu, expected: %lu)", end - buf, nal_size);
 169             return NULL;
 170         }
 171
 172         out_size += hb_nal_unit_write_annexb(NULL, buf, nal_size);
 173         buf      += nal_size;
 174     }
 175
 176     out = hb_buffer_init(out_size);
 177     if (out == NULL)
 178     {
 179         hb_error("hb_nal_bitstream_mp4_to_annexb: hb_buffer_init failed");
 180         return NULL;
 181     }
 182
 183     out_size = 0;
 184     buf      = (uint8_t*)data;
 185     end      = (uint8_t*)data + size;
 186
 187     while (end - buf > nal_length_size)
 188     {
 189         buf      += mp4_nal_unit_length(buf, nal_length_size, &nal_size);
 190         out_size += hb_nal_unit_write_annexb(out->data + out_size, buf, nal_size);
 191         buf      += nal_size;
 192     }
 193
 194     return out;
 195 }