2 * This file is part of FFmpeg.
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.
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.
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
19 static int FUNC(sequence_header)(CodedBitstreamContext *ctx, RWContext *rw,
20 MPEG2RawSequenceHeader *current)
22 CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
25 HEADER("Sequence Header");
27 ui(8, sequence_header_code);
29 ui(12, horizontal_size_value);
30 ui(12, vertical_size_value);
32 mpeg2->horizontal_size = current->horizontal_size_value;
33 mpeg2->vertical_size = current->vertical_size_value;
35 ui(4, aspect_ratio_information);
36 ui(4, frame_rate_code);
37 ui(18, bit_rate_value);
41 ui(10, vbv_buffer_size_value);
42 ui(1, constrained_parameters_flag);
44 ui(1, load_intra_quantiser_matrix);
45 if (current->load_intra_quantiser_matrix) {
46 for (i = 0; i < 64; i++)
47 ui(8, intra_quantiser_matrix[i]);
50 ui(1, load_non_intra_quantiser_matrix);
51 if (current->load_non_intra_quantiser_matrix) {
52 for (i = 0; i < 64; i++)
53 ui(8, non_intra_quantiser_matrix[i]);
59 static int FUNC(user_data)(CodedBitstreamContext *ctx, RWContext *rw,
60 MPEG2RawUserData *current)
67 ui(8, user_data_start_code);
70 k = get_bits_left(rw);
71 av_assert0(k % 8 == 0);
72 current->user_data_length = k /= 8;
74 current->user_data = av_malloc(k);
75 if (!current->user_data)
76 return AVERROR(ENOMEM);
80 for (k = 0; k < current->user_data_length; k++)
81 xui(8, user_data, current->user_data[k]);
86 static int FUNC(sequence_extension)(CodedBitstreamContext *ctx, RWContext *rw,
87 MPEG2RawSequenceExtension *current)
89 CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
92 HEADER("Sequence Extension");
94 ui(8, profile_and_level_indication);
95 ui(1, progressive_sequence);
97 ui(2, horizontal_size_extension);
98 ui(2, vertical_size_extension);
100 mpeg2->horizontal_size = (mpeg2->horizontal_size & 0xfff) |
101 current->horizontal_size_extension << 12;
102 mpeg2->vertical_size = (mpeg2->vertical_size & 0xfff) |
103 current->vertical_size_extension << 12;
104 mpeg2->progressive_sequence = current->progressive_sequence;
106 ui(12, bit_rate_extension);
108 ui(8, vbv_buffer_size_extension);
110 ui(2, frame_rate_extension_n);
111 ui(5, frame_rate_extension_d);
116 static int FUNC(sequence_display_extension)(CodedBitstreamContext *ctx, RWContext *rw,
117 MPEG2RawSequenceDisplayExtension *current)
121 HEADER("Sequence Display Extension");
125 ui(1, colour_description);
126 if (current->colour_description) {
127 ui(8, colour_primaries);
128 ui(8, transfer_characteristics);
129 ui(8, matrix_coefficients);
132 ui(14, display_horizontal_size);
134 ui(14, display_vertical_size);
139 static int FUNC(group_of_pictures_header)(CodedBitstreamContext *ctx, RWContext *rw,
140 MPEG2RawGroupOfPicturesHeader *current)
144 HEADER("Group of Pictures Header");
146 ui(8, group_start_code);
155 static int FUNC(picture_header)(CodedBitstreamContext *ctx, RWContext *rw,
156 MPEG2RawPictureHeader *current)
160 HEADER("Picture Header");
162 ui(8, picture_start_code);
164 ui(10, temporal_reference);
165 ui(3, picture_coding_type);
168 if (current->picture_coding_type == 2 ||
169 current->picture_coding_type == 3) {
170 ui(1, full_pel_forward_vector);
171 ui(3, forward_f_code);
174 if (current->picture_coding_type == 3) {
175 ui(1, full_pel_backward_vector);
176 ui(3, backward_f_code);
179 ui(1, extra_bit_picture);
184 static int FUNC(picture_coding_extension)(CodedBitstreamContext *ctx, RWContext *rw,
185 MPEG2RawPictureCodingExtension *current)
187 CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
190 HEADER("Picture Coding Extension");
197 ui(2, intra_dc_precision);
198 ui(2, picture_structure);
199 ui(1, top_field_first);
200 ui(1, frame_pred_frame_dct);
201 ui(1, concealment_motion_vectors);
203 ui(1, intra_vlc_format);
204 ui(1, alternate_scan);
205 ui(1, repeat_first_field);
206 ui(1, chroma_420_type);
207 ui(1, progressive_frame);
209 if (mpeg2->progressive_sequence) {
210 if (current->repeat_first_field) {
211 if (current->top_field_first)
212 mpeg2->number_of_frame_centre_offsets = 3;
214 mpeg2->number_of_frame_centre_offsets = 2;
216 mpeg2->number_of_frame_centre_offsets = 1;
219 if (current->picture_structure == 1 || // Top field.
220 current->picture_structure == 2) { // Bottom field.
221 mpeg2->number_of_frame_centre_offsets = 1;
223 if (current->repeat_first_field)
224 mpeg2->number_of_frame_centre_offsets = 3;
226 mpeg2->number_of_frame_centre_offsets = 2;
230 ui(1, composite_display_flag);
231 if (current->composite_display_flag) {
233 ui(3, field_sequence);
235 ui(7, burst_amplitude);
236 ui(8, sub_carrier_phase);
242 static int FUNC(quant_matrix_extension)(CodedBitstreamContext *ctx, RWContext *rw,
243 MPEG2RawQuantMatrixExtension *current)
247 HEADER("Quant Matrix Extension");
249 ui(1, load_intra_quantiser_matrix);
250 if (current->load_intra_quantiser_matrix) {
251 for (i = 0; i < 64; i++)
252 ui(8, intra_quantiser_matrix[i]);
255 ui(1, load_non_intra_quantiser_matrix);
256 if (current->load_non_intra_quantiser_matrix) {
257 for (i = 0; i < 64; i++)
258 ui(8, non_intra_quantiser_matrix[i]);
261 ui(1, load_chroma_intra_quantiser_matrix);
262 if (current->load_chroma_intra_quantiser_matrix) {
263 for (i = 0; i < 64; i++)
264 ui(8, intra_quantiser_matrix[i]);
267 ui(1, load_chroma_non_intra_quantiser_matrix);
268 if (current->load_chroma_non_intra_quantiser_matrix) {
269 for (i = 0; i < 64; i++)
270 ui(8, chroma_non_intra_quantiser_matrix[i]);
276 static int FUNC(picture_display_extension)(CodedBitstreamContext *ctx, RWContext *rw,
277 MPEG2RawPictureDisplayExtension *current)
279 CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
282 HEADER("Picture Display Extension");
284 for (i = 0; i < mpeg2->number_of_frame_centre_offsets; i++) {
285 ui(16, frame_centre_horizontal_offset[i]);
287 ui(16, frame_centre_vertical_offset[i]);
294 static int FUNC(extension_data)(CodedBitstreamContext *ctx, RWContext *rw,
295 MPEG2RawExtensionData *current)
299 HEADER("Extension Data");
301 ui(8, extension_start_code);
302 ui(4, extension_start_code_identifier);
304 switch (current->extension_start_code_identifier) {
306 return FUNC(sequence_extension)
307 (ctx, rw, ¤t->data.sequence);
309 return FUNC(sequence_display_extension)
310 (ctx, rw, ¤t->data.sequence_display);
312 return FUNC(quant_matrix_extension)
313 (ctx, rw, ¤t->data.quant_matrix);
315 return FUNC(picture_display_extension)
316 (ctx, rw, ¤t->data.picture_display);
318 return FUNC(picture_coding_extension)
319 (ctx, rw, ¤t->data.picture_coding);
321 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid extension ID %d.\n",
322 current->extension_start_code_identifier);
323 return AVERROR_INVALIDDATA;
327 static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,
328 MPEG2RawSliceHeader *current)
330 CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
333 HEADER("Slice Header");
335 ui(8, slice_vertical_position);
337 if (mpeg2->vertical_size > 2800)
338 ui(3, slice_vertical_position_extension);
339 if (mpeg2->scalable) {
340 if (mpeg2->scalable_mode == 0)
341 ui(7, priority_breakpoint);
344 ui(5, quantiser_scale_code);
346 if (nextbits(1, 1, current->slice_extension_flag)) {
347 ui(1, slice_extension_flag);
349 ui(1, slice_picture_id_enable);
350 ui(6, slice_picture_id);
358 for (k = 0; nextbits(1, 1, bit); k++)
360 current->extra_information_length = k;
363 current->extra_information =
364 av_malloc(current->extra_information_length);
365 if (!current->extra_information)
366 return AVERROR(ENOMEM);
367 for (k = 0; k < current->extra_information_length; k++) {
368 xui(1, extra_bit_slice, bit);
369 xui(8, extra_information_slice,
370 current->extra_information[k]);
374 for (k = 0; k < current->extra_information_length; k++) {
375 xui(1, extra_bit_slice, 1);
376 xui(8, extra_information_slice, current->extra_information[k]);
381 ui(1, extra_bit_slice);