libavcodec/cbs_mpeg2.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "libavutil/avassert.h"
  20
  21 #include "cbs.h"
  22 #include "cbs_internal.h"
  23 #include "cbs_mpeg2.h"
  24 #include "startcode.h"
  25
  26
  27 #define HEADER(name) do { \
  28         ff_cbs_trace_header(ctx, name); \
  29     } while (0)
  30
  31 #define CHECK(call) do { \
  32         err = (call); \
  33         if (err < 0) \
  34             return err; \
  35     } while (0)
  36
  37 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
  38 #define FUNC_MPEG2(rw, name) FUNC_NAME(rw, mpeg2, name)
  39 #define FUNC(name) FUNC_MPEG2(READWRITE, name)
  40
  41 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
  42
  43 #define ui(width, name) \
  44         xui(width, name, current->name, 0, MAX_UINT_BITS(width), 0, )
  45 #define uir(width, name) \
  46         xui(width, name, current->name, 1, MAX_UINT_BITS(width), 0, )
  47 #define uis(width, name, subs, ...) \
  48         xui(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
  49 #define uirs(width, name, subs, ...) \
  50         xui(width, name, current->name, 1, MAX_UINT_BITS(width), subs, __VA_ARGS__)
  51 #define xui(width, name, var, range_min, range_max, subs, ...) \
  52         xuia(width, #name, var, range_min, range_max, subs, __VA_ARGS__)
  53 #define sis(width, name, subs, ...) \
  54         xsi(width, name, current->name, subs, __VA_ARGS__)
  55
  56 #define marker_bit() \
  57         bit("marker_bit", 1)
  58 #define bit(string, value) do { \
  59         av_unused uint32_t bit = value; \
  60         xuia(1, string, bit, value, value, 0, ); \
  61     } while (0)
  62
  63
  64 #define READ
  65 #define READWRITE read
  66 #define RWContext GetBitContext
  67
  68 #define xuia(width, string, var, range_min, range_max, subs, ...) do { \
  69         uint32_t value; \
  70         CHECK(ff_cbs_read_unsigned(ctx, rw, width, string, \
  71                                    SUBSCRIPTS(subs, __VA_ARGS__), \
  72                                    &value, range_min, range_max)); \
  73         var = value; \
  74     } while (0)
  75
  76 #define xsi(width, name, var, subs, ...) do { \
  77         int32_t value; \
  78         CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
  79                                  SUBSCRIPTS(subs, __VA_ARGS__), &value, \
  80                                  MIN_INT_BITS(width), \
  81                                  MAX_INT_BITS(width))); \
  82         var = value; \
  83     } while (0)
  84
  85 #define nextbits(width, compare, var) \
  86     (get_bits_left(rw) >= width && \
  87      (var = show_bits(rw, width)) == (compare))
  88
  89 #define infer(name, value) do { \
  90         current->name = value; \
  91     } while (0)
  92
  93 #include "cbs_mpeg2_syntax_template.c"
  94
  95 #undef READ
  96 #undef READWRITE
  97 #undef RWContext
  98 #undef xuia
  99 #undef xsi
 100 #undef nextbits
 101 #undef infer
 102
 103
 104 #define WRITE
 105 #define READWRITE write
 106 #define RWContext PutBitContext
 107
 108 #define xuia(width, string, var, range_min, range_max, subs, ...) do { \
 109         CHECK(ff_cbs_write_unsigned(ctx, rw, width, string, \
 110                                     SUBSCRIPTS(subs, __VA_ARGS__), \
 111                                     var, range_min, range_max)); \
 112     } while (0)
 113
 114 #define xsi(width, name, var, subs, ...) do { \
 115         CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
 116                                   SUBSCRIPTS(subs, __VA_ARGS__), var, \
 117                                   MIN_INT_BITS(width), \
 118                                   MAX_INT_BITS(width))); \
 119     } while (0)
 120
 121 #define nextbits(width, compare, var) (var)
 122
 123 #define infer(name, value) do { \
 124         if (current->name != (value)) { \
 125             av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
 126                    "%s does not match inferred value: " \
 127                    "%"PRId64", but should be %"PRId64".\n", \
 128                    #name, (int64_t)current->name, (int64_t)(value)); \
 129         } \
 130     } while (0)
 131
 132 #include "cbs_mpeg2_syntax_template.c"
 133
 134 #undef WRITE
 135 #undef READWRITE
 136 #undef RWContext
 137 #undef xuia
 138 #undef xsi
 139 #undef nextbits
 140 #undef infer
 141
 142
 143 static int cbs_mpeg2_split_fragment(CodedBitstreamContext *ctx,
 144                                     CodedBitstreamFragment *frag,
 145                                     int header)
 146 {
 147     const uint8_t *start;
 148     uint32_t start_code = -1;
 149     int err;
 150
 151     start = avpriv_find_start_code(frag->data, frag->data + frag->data_size,
 152                                    &start_code);
 153     if (start_code >> 8 != 0x000001) {
 154         // No start code found.
 155         return AVERROR_INVALIDDATA;
 156     }
 157
 158     do {
 159         CodedBitstreamUnitType unit_type = start_code & 0xff;
 160         const uint8_t *end;
 161         size_t unit_size;
 162
 163         // Reset start_code to ensure that avpriv_find_start_code()
 164         // really reads a new start code and does not reuse the old
 165         // start code in any way (as e.g. happens when there is a
 166         // Sequence End unit at the very end of a packet).
 167         start_code = UINT32_MAX;
 168         end = avpriv_find_start_code(start--, frag->data + frag->data_size,
 169                                      &start_code);
 170
 171         // start points to the byte containing the start_code_identifier
 172         // (may be the last byte of fragment->data); end points to the byte
 173         // following the byte containing the start code identifier (or to
 174         // the end of fragment->data).
 175         if (start_code >> 8 == 0x000001) {
 176             // Unit runs from start to the beginning of the start code
 177             // pointed to by end (including any padding zeroes).
 178             unit_size = (end - 4) - start;
 179         } else {
 180            // We didn't find a start code, so this is the final unit.
 181            unit_size = end - start;
 182         }
 183
 184         err = ff_cbs_append_unit_data(frag, unit_type, (uint8_t*)start,
 185                                       unit_size, frag->data_ref);
 186         if (err < 0)
 187             return err;
 188
 189         start = end;
 190
 191         // Do we have a further unit to add to the fragment?
 192     } while ((start_code >> 8) == 0x000001);
 193
 194     return 0;
 195 }
 196
 197 static int cbs_mpeg2_read_unit(CodedBitstreamContext *ctx,
 198                                CodedBitstreamUnit *unit)
 199 {
 200     GetBitContext gbc;
 201     int err;
 202
 203     err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
 204     if (err < 0)
 205         return err;
 206
 207     err = ff_cbs_alloc_unit_content2(ctx, unit);
 208     if (err < 0)
 209         return err;
 210
 211     if (MPEG2_START_IS_SLICE(unit->type)) {
 212         MPEG2RawSlice *slice = unit->content;
 213         int pos, len;
 214
 215         err = cbs_mpeg2_read_slice_header(ctx, &gbc, &slice->header);
 216         if (err < 0)
 217             return err;
 218
 219         if (!get_bits_left(&gbc))
 220             return AVERROR_INVALIDDATA;
 221
 222         pos = get_bits_count(&gbc);
 223         len = unit->data_size;
 224
 225         slice->data_size = len - pos / 8;
 226         slice->data_ref  = av_buffer_ref(unit->data_ref);
 227         if (!slice->data_ref)
 228             return AVERROR(ENOMEM);
 229         slice->data = unit->data + pos / 8;
 230
 231         slice->data_bit_start = pos % 8;
 232
 233     } else {
 234         switch (unit->type) {
 235 #define START(start_code, type, read_func, free_func) \
 236         case start_code: \
 237             { \
 238                 type *header = unit->content; \
 239                 err = cbs_mpeg2_read_ ## read_func(ctx, &gbc, header); \
 240                 if (err < 0) \
 241                     return err; \
 242             } \
 243             break;
 244             START(MPEG2_START_PICTURE,   MPEG2RawPictureHeader,
 245                   picture_header,           &cbs_mpeg2_free_picture_header);
 246             START(MPEG2_START_USER_DATA, MPEG2RawUserData,
 247                   user_data,                &cbs_mpeg2_free_user_data);
 248             START(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader,
 249                   sequence_header,          NULL);
 250             START(MPEG2_START_EXTENSION, MPEG2RawExtensionData,
 251                   extension_data,           NULL);
 252             START(MPEG2_START_GROUP,     MPEG2RawGroupOfPicturesHeader,
 253                   group_of_pictures_header, NULL);
 254             START(MPEG2_START_SEQUENCE_END, MPEG2RawSequenceEnd,
 255                   sequence_end,             NULL);
 256 #undef START
 257         default:
 258             return AVERROR(ENOSYS);
 259         }
 260     }
 261
 262     return 0;
 263 }
 264
 265 static int cbs_mpeg2_write_header(CodedBitstreamContext *ctx,
 266                                   CodedBitstreamUnit *unit,
 267                                   PutBitContext *pbc)
 268 {
 269     int err;
 270
 271     switch (unit->type) {
 272 #define START(start_code, type, func) \
 273     case start_code: \
 274         err = cbs_mpeg2_write_ ## func(ctx, pbc, unit->content); \
 275         break;
 276         START(MPEG2_START_PICTURE,         MPEG2RawPictureHeader,  picture_header);
 277         START(MPEG2_START_USER_DATA,       MPEG2RawUserData,       user_data);
 278         START(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader, sequence_header);
 279         START(MPEG2_START_EXTENSION,       MPEG2RawExtensionData,  extension_data);
 280         START(MPEG2_START_GROUP,           MPEG2RawGroupOfPicturesHeader,
 281                                                          group_of_pictures_header);
 282         START(MPEG2_START_SEQUENCE_END,    MPEG2RawSequenceEnd,    sequence_end);
 283 #undef START
 284     default:
 285         av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for start "
 286                "code %02"PRIx32".\n", unit->type);
 287         return AVERROR_PATCHWELCOME;
 288     }
 289
 290     return err;
 291 }
 292
 293 static int cbs_mpeg2_write_slice(CodedBitstreamContext *ctx,
 294                                  CodedBitstreamUnit *unit,
 295                                  PutBitContext *pbc)
 296 {
 297     MPEG2RawSlice *slice = unit->content;
 298     int err;
 299
 300     err = cbs_mpeg2_write_slice_header(ctx, pbc, &slice->header);
 301     if (err < 0)
 302         return err;
 303
 304     if (slice->data) {
 305         size_t rest = slice->data_size - (slice->data_bit_start + 7) / 8;
 306         uint8_t *pos = slice->data + slice->data_bit_start / 8;
 307
 308         av_assert0(slice->data_bit_start >= 0 &&
 309                    slice->data_size > slice->data_bit_start / 8);
 310
 311         if (slice->data_size * 8 + 8 > put_bits_left(pbc))
 312             return AVERROR(ENOSPC);
 313
 314         // First copy the remaining bits of the first byte
 315         if (slice->data_bit_start % 8)
 316             put_bits(pbc, 8 - slice->data_bit_start % 8,
 317                      *pos++ & MAX_UINT_BITS(8 - slice->data_bit_start % 8));
 318
 319         if (put_bits_count(pbc) % 8 == 0) {
 320             // If the writer is aligned at this point,
 321             // memcpy can be used to improve performance.
 322             // This is the normal case.
 323             flush_put_bits(pbc);
 324             memcpy(put_bits_ptr(pbc), pos, rest);
 325             skip_put_bytes(pbc, rest);
 326         } else {
 327             // If not, we have to copy manually:
 328             for (; rest > 3; rest -= 4, pos += 4)
 329                 put_bits32(pbc, AV_RB32(pos));
 330
 331             for (; rest; rest--, pos++)
 332                 put_bits(pbc, 8, *pos);
 333
 334             // Align with zeros
 335             put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0);
 336         }
 337     }
 338
 339     return 0;
 340 }
 341
 342 static int cbs_mpeg2_write_unit(CodedBitstreamContext *ctx,
 343                                 CodedBitstreamUnit *unit,
 344                                 PutBitContext *pbc)
 345 {
 346     if (MPEG2_START_IS_SLICE(unit->type))
 347         return cbs_mpeg2_write_slice (ctx, unit, pbc);
 348     else
 349         return cbs_mpeg2_write_header(ctx, unit, pbc);
 350 }
 351
 352 static int cbs_mpeg2_assemble_fragment(CodedBitstreamContext *ctx,
 353                                        CodedBitstreamFragment *frag)
 354 {
 355     uint8_t *data;
 356     size_t size, dp;
 357     int i;
 358
 359     size = 0;
 360     for (i = 0; i < frag->nb_units; i++)
 361         size += 3 + frag->units[i].data_size;
 362
 363     frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
 364     if (!frag->data_ref)
 365         return AVERROR(ENOMEM);
 366     data = frag->data_ref->data;
 367
 368     dp = 0;
 369     for (i = 0; i < frag->nb_units; i++) {
 370         CodedBitstreamUnit *unit = &frag->units[i];
 371
 372         data[dp++] = 0;
 373         data[dp++] = 0;
 374         data[dp++] = 1;
 375
 376         memcpy(data + dp, unit->data, unit->data_size);
 377         dp += unit->data_size;
 378     }
 379
 380     av_assert0(dp == size);
 381
 382     memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 383     frag->data      = data;
 384     frag->data_size = size;
 385
 386     return 0;
 387 }
 388
 389 static const CodedBitstreamUnitTypeDescriptor cbs_mpeg2_unit_types[] = {
 390     CBS_UNIT_TYPE_INTERNAL_REF(MPEG2_START_PICTURE, MPEG2RawPictureHeader,
 391                                extra_information_picture.extra_information),
 392
 393     {
 394         .nb_unit_types         = CBS_UNIT_TYPE_RANGE,
 395         .unit_type_range_start = 0x01,
 396         .unit_type_range_end   = 0xaf,
 397
 398         .content_type   = CBS_CONTENT_TYPE_INTERNAL_REFS,
 399         .content_size   = sizeof(MPEG2RawSlice),
 400         .nb_ref_offsets = 2,
 401         .ref_offsets    = { offsetof(MPEG2RawSlice, header.extra_information_slice.extra_information),
 402                             offsetof(MPEG2RawSlice, data) },
 403     },
 404
 405     CBS_UNIT_TYPE_INTERNAL_REF(MPEG2_START_USER_DATA, MPEG2RawUserData,
 406                                user_data),
 407
 408     CBS_UNIT_TYPE_POD(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader),
 409     CBS_UNIT_TYPE_POD(MPEG2_START_EXTENSION,       MPEG2RawExtensionData),
 410     CBS_UNIT_TYPE_POD(MPEG2_START_SEQUENCE_END,    MPEG2RawSequenceEnd),
 411     CBS_UNIT_TYPE_POD(MPEG2_START_GROUP,           MPEG2RawGroupOfPicturesHeader),
 412
 413     CBS_UNIT_TYPE_END_OF_LIST
 414 };
 415
 416 const CodedBitstreamType ff_cbs_type_mpeg2 = {
 417     .codec_id          = AV_CODEC_ID_MPEG2VIDEO,
 418
 419     .priv_data_size    = sizeof(CodedBitstreamMPEG2Context),
 420
 421     .unit_types        = cbs_mpeg2_unit_types,
 422
 423     .split_fragment    = &cbs_mpeg2_split_fragment,
 424     .read_unit         = &cbs_mpeg2_read_unit,
 425     .write_unit        = &cbs_mpeg2_write_unit,
 426     .assemble_fragment = &cbs_mpeg2_assemble_fragment,
 427 };