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 143static 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 197static 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 265static 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 293static 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 342static 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 352static 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 389static 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 416const 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}; 428