2 * Copyright (c) 2012 Intel Corporation. All Rights Reserved.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 * Simple MPEG-2 encoder based on libVA.
35 #include <sys/types.h>
41 #include <va/va_enc_mpeg2.h>
43 #include "va_display.h"
45 #define START_CODE_PICUTRE 0x00000100
46 #define START_CODE_SLICE 0x00000101
47 #define START_CODE_USER 0x000001B2
48 #define START_CODE_SEQ 0x000001B3
49 #define START_CODE_EXT 0x000001B5
50 #define START_CODE_GOP 0x000001B8
52 #define CHROMA_FORMAT_RESERVED 0
53 #define CHROMA_FORMAT_420 1
54 #define CHROMA_FORMAT_422 2
55 #define CHROMA_FORMAT_444 3
57 #define MAX_SLICES 128
71 #define CHECK_VASTATUS(va_status, func) \
72 if (va_status != VA_STATUS_SUCCESS) { \
73 fprintf(stderr, "%s:%s (%d) failed, exit\n", __func__, func, __LINE__); \
77 static VAProfile mpeg2_va_profiles[] = {
82 static struct _mpeg2_sampling_density
84 int samplers_per_line;
87 } mpeg2_upper_samplings[2][3] = {
99 struct mpeg2enc_context {
101 int rate_control_mode;
103 int mode; /* 0:I, 1:I/P, 2:I/P/B */
113 unsigned char *frame_data_buffer;
116 int bit_rate; /* in kbps */
117 VAEncPictureType next_type;
118 int next_display_order;
122 int gop_header_in_display_order;
126 VAEncSequenceParameterBufferMPEG2 seq_param;
127 VAEncPictureParameterBufferMPEG2 pic_param;
128 VAEncSliceParameterBufferMPEG2 slice_param[MAX_SLICES];
129 VAContextID context_id;
130 VAConfigID config_id;
131 VABufferID seq_param_buf_id; /* Sequence level parameter */
132 VABufferID pic_param_buf_id; /* Picture level parameter */
133 VABufferID slice_param_buf_id[MAX_SLICES]; /* Slice level parameter, multil slices */
134 VABufferID codedbuf_buf_id; /* Output buffer, compressed data */
135 VABufferID packed_seq_header_param_buf_id;
136 VABufferID packed_seq_buf_id;
137 VABufferID packed_pic_header_param_buf_id;
138 VABufferID packed_pic_buf_id;
139 int num_slice_groups;
141 int codedbuf_pb_size;
144 pthread_t upload_thread_id;
145 int upload_thread_value;
146 int current_input_surface;
147 int current_upload_surface;
153 #define BITSTREAM_ALLOCATE_STEPPING 4096
156 unsigned int *buffer;
158 int max_size_in_dword;
161 typedef struct __bitstream bitstream;
164 swap32(unsigned int val)
166 unsigned char *pval = (unsigned char *)&val;
168 return ((pval[0] << 24) |
175 bitstream_start(bitstream *bs)
177 bs->max_size_in_dword = BITSTREAM_ALLOCATE_STEPPING;
178 bs->buffer = calloc(bs->max_size_in_dword * sizeof(int), 1);
183 bitstream_end(bitstream *bs)
185 int pos = (bs->bit_offset >> 5);
186 int bit_offset = (bs->bit_offset & 0x1f);
187 int bit_left = 32 - bit_offset;
190 bs->buffer[pos] = swap32((bs->buffer[pos] << bit_left));
195 bitstream_put_ui(bitstream *bs, unsigned int val, int size_in_bits)
197 int pos = (bs->bit_offset >> 5);
198 int bit_offset = (bs->bit_offset & 0x1f);
199 int bit_left = 32 - bit_offset;
204 if (size_in_bits < 32)
205 val &= ((1 << size_in_bits) - 1);
207 bs->bit_offset += size_in_bits;
209 if (bit_left > size_in_bits) {
210 bs->buffer[pos] = (bs->buffer[pos] << size_in_bits | val);
212 size_in_bits -= bit_left;
213 bs->buffer[pos] = (bs->buffer[pos] << bit_left) | (val >> size_in_bits);
214 bs->buffer[pos] = swap32(bs->buffer[pos]);
216 if (pos + 1 == bs->max_size_in_dword) {
217 bs->max_size_in_dword += BITSTREAM_ALLOCATE_STEPPING;
218 bs->buffer = realloc(bs->buffer, bs->max_size_in_dword * sizeof(unsigned int));
221 bs->buffer[pos + 1] = val;
226 bitstream_byte_aligning(bitstream *bs, int bit)
228 int bit_offset = (bs->bit_offset & 0x7);
229 int bit_left = 8 - bit_offset;
235 assert(bit == 0 || bit == 1);
238 new_val = (1 << bit_left) - 1;
242 bitstream_put_ui(bs, new_val, bit_left);
245 static struct mpeg2_frame_rate {
248 } frame_rate_tab[] = {
260 find_frame_rate_code(const VAEncSequenceParameterBufferMPEG2 *seq_param)
262 unsigned int delta = -1;
264 float frame_rate_value = seq_param->frame_rate *
265 (seq_param->sequence_extension.bits.frame_rate_extension_d + 1) /
266 (seq_param->sequence_extension.bits.frame_rate_extension_n + 1);
268 for (i = 0; i < sizeof(frame_rate_tab) / sizeof(frame_rate_tab[0]); i++) {
270 if (abs(1000 * frame_rate_tab[i].value - 1000 * frame_rate_value) < delta) {
271 code = frame_rate_tab[i].code;
272 delta = abs(1000 * frame_rate_tab[i].value - 1000 * frame_rate_value);
280 sps_rbsp(struct mpeg2enc_context *ctx,
281 const VAEncSequenceParameterBufferMPEG2 *seq_param,
284 int frame_rate_code = find_frame_rate_code(seq_param);
286 if (ctx->new_sequence) {
287 bitstream_put_ui(bs, START_CODE_SEQ, 32);
288 bitstream_put_ui(bs, seq_param->picture_width, 12);
289 bitstream_put_ui(bs, seq_param->picture_height, 12);
290 bitstream_put_ui(bs, seq_param->aspect_ratio_information, 4);
291 bitstream_put_ui(bs, frame_rate_code, 4); /* frame_rate_code */
292 bitstream_put_ui(bs, (seq_param->bits_per_second + 399) / 400, 18); /* the low 18 bits of bit_rate */
293 bitstream_put_ui(bs, 1, 1); /* marker_bit */
294 bitstream_put_ui(bs, seq_param->vbv_buffer_size, 10);
295 bitstream_put_ui(bs, 0, 1); /* constraint_parameter_flag, always 0 for MPEG-2 */
296 bitstream_put_ui(bs, 0, 1); /* load_intra_quantiser_matrix */
297 bitstream_put_ui(bs, 0, 1); /* load_non_intra_quantiser_matrix */
299 bitstream_byte_aligning(bs, 0);
301 bitstream_put_ui(bs, START_CODE_EXT, 32);
302 bitstream_put_ui(bs, 1, 4); /* sequence_extension id */
303 bitstream_put_ui(bs, seq_param->sequence_extension.bits.profile_and_level_indication, 8);
304 bitstream_put_ui(bs, seq_param->sequence_extension.bits.progressive_sequence, 1);
305 bitstream_put_ui(bs, seq_param->sequence_extension.bits.chroma_format, 2);
306 bitstream_put_ui(bs, seq_param->picture_width >> 12, 2);
307 bitstream_put_ui(bs, seq_param->picture_height >> 12, 2);
308 bitstream_put_ui(bs, ((seq_param->bits_per_second + 399) / 400) >> 18, 12); /* bit_rate_extension */
309 bitstream_put_ui(bs, 1, 1); /* marker_bit */
310 bitstream_put_ui(bs, seq_param->vbv_buffer_size >> 10, 8);
311 bitstream_put_ui(bs, seq_param->sequence_extension.bits.low_delay, 1);
312 bitstream_put_ui(bs, seq_param->sequence_extension.bits.frame_rate_extension_n, 2);
313 bitstream_put_ui(bs, seq_param->sequence_extension.bits.frame_rate_extension_d, 5);
315 bitstream_byte_aligning(bs, 0);
318 if (ctx->new_gop_header) {
319 bitstream_put_ui(bs, START_CODE_GOP, 32);
320 bitstream_put_ui(bs, seq_param->gop_header.bits.time_code, 25);
321 bitstream_put_ui(bs, seq_param->gop_header.bits.closed_gop, 1);
322 bitstream_put_ui(bs, seq_param->gop_header.bits.broken_link, 1);
324 bitstream_byte_aligning(bs, 0);
329 pps_rbsp(const VAEncSequenceParameterBufferMPEG2 *seq_param,
330 const VAEncPictureParameterBufferMPEG2 *pic_param,
336 if (seq_param->sequence_extension.bits.chroma_format == CHROMA_FORMAT_420)
337 chroma_420_type = pic_param->picture_coding_extension.bits.progressive_frame;
341 bitstream_put_ui(bs, START_CODE_PICUTRE, 32);
342 bitstream_put_ui(bs, pic_param->temporal_reference, 10);
344 pic_param->picture_type == VAEncPictureTypeIntra ? 1 :
345 pic_param->picture_type == VAEncPictureTypePredictive ? 2 : 3,
347 bitstream_put_ui(bs, 0xFFFF, 16); /* vbv_delay, always 0xFFFF */
349 if (pic_param->picture_type == VAEncPictureTypePredictive ||
350 pic_param->picture_type == VAEncPictureTypeBidirectional) {
351 bitstream_put_ui(bs, 0, 1); /* full_pel_forward_vector, always 0 for MPEG-2 */
352 bitstream_put_ui(bs, 7, 3); /* forward_f_code, always 7 for MPEG-2 */
355 if (pic_param->picture_type == VAEncPictureTypeBidirectional) {
356 bitstream_put_ui(bs, 0, 1); /* full_pel_backward_vector, always 0 for MPEG-2 */
357 bitstream_put_ui(bs, 7, 3); /* backward_f_code, always 7 for MPEG-2 */
360 bitstream_put_ui(bs, 0, 1); /* extra_bit_picture, 0 */
362 bitstream_byte_aligning(bs, 0);
364 bitstream_put_ui(bs, START_CODE_EXT, 32);
365 bitstream_put_ui(bs, 8, 4); /* Picture Coding Extension ID: 8 */
366 bitstream_put_ui(bs, pic_param->f_code[0][0], 4);
367 bitstream_put_ui(bs, pic_param->f_code[0][1], 4);
368 bitstream_put_ui(bs, pic_param->f_code[1][0], 4);
369 bitstream_put_ui(bs, pic_param->f_code[1][1], 4);
371 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.intra_dc_precision, 2);
372 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.picture_structure, 2);
373 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.top_field_first, 1);
374 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.frame_pred_frame_dct, 1);
375 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.concealment_motion_vectors, 1);
376 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.q_scale_type, 1);
377 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.intra_vlc_format, 1);
378 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.alternate_scan, 1);
379 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.repeat_first_field, 1);
380 bitstream_put_ui(bs, chroma_420_type, 1);
381 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.progressive_frame, 1);
382 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.composite_display_flag, 1);
384 bitstream_byte_aligning(bs, 0);
386 if (pic_param->user_data_length) {
387 bitstream_put_ui(bs, START_CODE_USER, 32);
389 for (i = 0; i < pic_param->user_data_length; i++) {
390 bitstream_put_ui(bs, pic_param->user_data[i], 8);
393 bitstream_byte_aligning(bs, 0);
398 build_packed_pic_buffer(const VAEncSequenceParameterBufferMPEG2 *seq_param,
399 const VAEncPictureParameterBufferMPEG2 *pic_param,
400 unsigned char **header_buffer)
404 bitstream_start(&bs);
405 pps_rbsp(seq_param, pic_param, &bs);
408 *header_buffer = (unsigned char *)bs.buffer;
409 return bs.bit_offset;
413 build_packed_seq_buffer(struct mpeg2enc_context *ctx,
414 const VAEncSequenceParameterBufferMPEG2 *seq_param,
415 unsigned char **header_buffer)
419 bitstream_start(&bs);
420 sps_rbsp(ctx, seq_param, &bs);
423 *header_buffer = (unsigned char *)bs.buffer;
424 return bs.bit_offset;
430 #define SID_INPUT_PICTURE_0 0
431 #define SID_INPUT_PICTURE_1 1
432 #define SID_REFERENCE_PICTURE_L0 2
433 #define SID_REFERENCE_PICTURE_L1 3
434 #define SID_RECON_PICTURE 4
435 #define SID_NUMBER SID_RECON_PICTURE + 1
437 static VASurfaceID surface_ids[SID_NUMBER];
440 * upload thread function
443 upload_yuv_to_surface(void *data)
445 struct mpeg2enc_context *ctx = data;
446 VAImage surface_image;
448 void *surface_p = NULL;
449 unsigned char *y_src, *u_src, *v_src;
450 unsigned char *y_dst, *u_dst, *v_dst;
451 int y_size = ctx->width * ctx->height;
452 int u_size = (ctx->width >> 1) * (ctx->height >> 1);
457 n_items = fread(ctx->frame_data_buffer, ctx->frame_size, 1, ctx->ifp);
458 } while (n_items != 1);
460 va_status = vaDeriveImage(ctx->va_dpy, surface_ids[ctx->current_upload_surface], &surface_image);
461 CHECK_VASTATUS(va_status,"vaDeriveImage");
463 vaMapBuffer(ctx->va_dpy, surface_image.buf, &surface_p);
464 assert(VA_STATUS_SUCCESS == va_status);
466 y_src = ctx->frame_data_buffer;
467 u_src = ctx->frame_data_buffer + y_size; /* UV offset for NV12 */
468 v_src = ctx->frame_data_buffer + y_size + u_size;
470 y_dst = surface_p + surface_image.offsets[0];
471 u_dst = surface_p + surface_image.offsets[1]; /* UV offset for NV12 */
472 v_dst = surface_p + surface_image.offsets[2];
475 for (row = 0; row < surface_image.height; row++) {
476 memcpy(y_dst, y_src, surface_image.width);
477 y_dst += surface_image.pitches[0];
481 if (surface_image.format.fourcc == VA_FOURCC_NV12) { /* UV plane */
482 for (row = 0; row < surface_image.height / 2; row++) {
483 for (col = 0; col < surface_image.width / 2; col++) {
484 u_dst[col * 2] = u_src[col];
485 u_dst[col * 2 + 1] = v_src[col];
488 u_dst += surface_image.pitches[1];
489 u_src += (ctx->width / 2);
490 v_src += (ctx->width / 2);
493 for (row = 0; row < surface_image.height / 2; row++) {
494 for (col = 0; col < surface_image.width / 2; col++) {
495 u_dst[col] = u_src[col];
496 v_dst[col] = v_src[col];
499 u_dst += surface_image.pitches[1];
500 v_dst += surface_image.pitches[2];
501 u_src += (ctx->width / 2);
502 v_src += (ctx->width / 2);
506 vaUnmapBuffer(ctx->va_dpy, surface_image.buf);
507 vaDestroyImage(ctx->va_dpy, surface_image.image_id);
513 mpeg2enc_exit(struct mpeg2enc_context *ctx, int exit_code)
515 if (ctx->frame_data_buffer) {
516 free(ctx->frame_data_buffer);
517 ctx->frame_data_buffer = NULL;
536 fprintf(stderr, "Usage: %s --help\n", program);
537 fprintf(stderr, "\t--help print this message\n");
538 fprintf(stderr, "Usage: %s <width> <height> <ifile> <ofile> [options]\n", program);
539 fprintf(stderr, "\t<width> specifies the frame width\n");
540 fprintf(stderr, "\t<height> specifies the frame height\n");
541 fprintf(stderr, "\t<ifile> specifies the I420/IYUV YUV file\n");
542 fprintf(stderr, "\t<ofile> specifies the encoded MPEG-2 file\n");
543 fprintf(stderr, "where options include:\n");
544 fprintf(stderr, "\t--cqp <QP> const qp mode with specified <QP>\n");
545 fprintf(stderr, "\t--fps <FPS> specify the frame rate\n");
546 fprintf(stderr, "\t--mode <MODE> specify the mode 0 (I), 1 (I/P) and 2 (I/P/B)\n");
547 fprintf(stderr, "\t--profile <PROFILE> specify the profile 0(Simple), or 1(Main, default)\n");
548 fprintf(stderr, "\t--level <LEVEL> specify the level 0(Low), 1(Main, default) or 2(High)\n");
552 mpeg2_profile_level(struct mpeg2enc_context *ctx,
558 for (p = profile; p < 2; p++) {
559 for (l = level; l < 3; l++) {
560 if (ctx->width <= mpeg2_upper_samplings[p][l].samplers_per_line &&
561 ctx->height <= mpeg2_upper_samplings[p][l].line_per_frame &&
562 ctx->fps <= mpeg2_upper_samplings[p][l].frame_per_sec) {
571 fprintf(stderr, "Warning: can't find a proper profile and level for the specified width/height/fps\n");
577 ctx->profile = mpeg2_va_profiles[p];
582 parse_args(struct mpeg2enc_context *ctx, int argc, char **argv)
585 int option_index = 0;
587 int profile = 1, level = 1;
589 static struct option long_options[] = {
590 {"help", no_argument, 0, 'h'},
591 {"cqp", required_argument, 0, 'c'},
592 {"fps", required_argument, 0, 'f'},
593 {"mode", required_argument, 0, 'm'},
594 {"profile", required_argument, 0, 'p'},
595 {"level", required_argument, 0, 'l'},
599 if ((argc == 2 && strcmp(argv[1], "--help") == 0) ||
603 ctx->width = atoi(argv[1]);
604 ctx->height = atoi(argv[2]);
606 if (ctx->width <= 0 || ctx->height <= 0) {
607 fprintf(stderr, "<width> and <height> must be greater than 0\n");
611 ctx->ifp = fopen(argv[3], "rb");
613 if (ctx->ifp == NULL) {
614 fprintf(stderr, "Can't open the input file\n");
618 fseek(ctx->ifp, 0l, SEEK_END);
619 file_size = ftell(ctx->ifp);
620 ctx->frame_size = ctx->width * ctx->height * 3 / 2;
622 if ((file_size < ctx->frame_size) ||
623 (file_size % ctx->frame_size)) {
624 fprintf(stderr, "The input file size %ld isn't a multiple of the frame size %d\n", file_size, ctx->frame_size);
628 ctx->num_pictures = file_size / ctx->frame_size;
629 fseek(ctx->ifp, 0l, SEEK_SET);
631 ctx->ofp = fopen(argv[4], "wb");
633 if (ctx->ofp == NULL) {
634 fprintf(stderr, "Can't create the output file\n");
641 ctx->rate_control_mode = VA_RC_CQP;
642 ctx->mode = MPEG2_MODE_IP;
643 ctx->profile = VAProfileMPEG2Main;
644 ctx->level = MPEG2_LEVEL_MAIN;
648 while((c = getopt_long(argc, argv,
651 &option_index)) != -1) {
656 /* only support q_scale_type = 0 */
657 if (tmp > 62 || tmp < 2) {
658 fprintf(stderr, "Warning: QP must be in [2, 62]\n");
667 ctx->qp = tmp & 0xFE;
668 ctx->rate_control_mode = VA_RC_CQP;
676 fprintf(stderr, "Warning: FPS must be greater than 0\n");
680 ctx->rate_control_mode = VA_RC_CBR;
687 if (tmp < MPEG2_MODE_I || tmp > MPEG2_MODE_IPB)
688 fprintf(stderr, "Waning: MODE must be 0, 1, or 2\n");
697 if (tmp < 0 || tmp > 1)
698 fprintf(stderr, "Waning: PROFILE must be 0 or 1\n");
707 if (tmp < MPEG2_LEVEL_LOW || tmp > MPEG2_LEVEL_HIGH)
708 fprintf(stderr, "Waning: LEVEL must be 0, 1, or 2\n");
715 fprintf(stderr, "Error: unkown command options\n");
722 mpeg2_profile_level(ctx, profile, level);
729 mpeg2enc_exit(ctx, 1);
736 mpeg2enc_init_sequence_parameter(struct mpeg2enc_context *ctx,
737 VAEncSequenceParameterBufferMPEG2 *seq_param)
739 int profile = 4, level = 8;
741 switch (ctx->profile) {
742 case VAProfileMPEG2Simple:
746 case VAProfileMPEG2Main:
755 switch (ctx->level) {
756 case MPEG2_LEVEL_LOW:
760 case MPEG2_LEVEL_MAIN:
764 case MPEG2_LEVEL_HIGH:
773 seq_param->intra_period = ctx->intra_period;
774 seq_param->ip_period = ctx->ip_period; /* FIXME: ??? */
775 seq_param->picture_width = ctx->width;
776 seq_param->picture_height = ctx->height;
778 if (ctx->bit_rate > 0)
779 seq_param->bits_per_second = 1024 * ctx->bit_rate; /* use kbps as input */
781 seq_param->bits_per_second = 0x3FFFF * 400;
783 seq_param->frame_rate = ctx->fps;
784 seq_param->aspect_ratio_information = 1;
785 seq_param->vbv_buffer_size = 3; /* B = 16 * 1024 * vbv_buffer_size */
787 seq_param->sequence_extension.bits.profile_and_level_indication = profile << 4 | level;
788 seq_param->sequence_extension.bits.progressive_sequence = 1; /* progressive frame-pictures */
789 seq_param->sequence_extension.bits.chroma_format = CHROMA_FORMAT_420; /* 4:2:0 */
790 seq_param->sequence_extension.bits.low_delay = 0; /* FIXME */
791 seq_param->sequence_extension.bits.frame_rate_extension_n = 0;
792 seq_param->sequence_extension.bits.frame_rate_extension_d = 0;
794 seq_param->gop_header.bits.time_code = (1 << 12); /* bit12: marker_bit */
795 seq_param->gop_header.bits.closed_gop = 0;
796 seq_param->gop_header.bits.broken_link = 0;
800 mpeg2enc_init_picture_parameter(struct mpeg2enc_context *ctx,
801 VAEncPictureParameterBufferMPEG2 *pic_param)
803 pic_param->forward_reference_picture = VA_INVALID_ID;
804 pic_param->backward_reference_picture = VA_INVALID_ID;
805 pic_param->reconstructed_picture = VA_INVALID_ID;
806 pic_param->coded_buf = VA_INVALID_ID;
807 pic_param->picture_type = VAEncPictureTypeIntra;
809 pic_param->temporal_reference = 0;
810 pic_param->f_code[0][0] = 0xf;
811 pic_param->f_code[0][1] = 0xf;
812 pic_param->f_code[1][0] = 0xf;
813 pic_param->f_code[1][1] = 0xf;
815 pic_param->picture_coding_extension.bits.intra_dc_precision = 0; /* 8bits */
816 pic_param->picture_coding_extension.bits.picture_structure = 3; /* frame picture */
817 pic_param->picture_coding_extension.bits.top_field_first = 0;
818 pic_param->picture_coding_extension.bits.frame_pred_frame_dct = 1; /* FIXME */
819 pic_param->picture_coding_extension.bits.concealment_motion_vectors = 0;
820 pic_param->picture_coding_extension.bits.q_scale_type = 0;
821 pic_param->picture_coding_extension.bits.intra_vlc_format = 0;
822 pic_param->picture_coding_extension.bits.alternate_scan = 0;
823 pic_param->picture_coding_extension.bits.repeat_first_field = 0;
824 pic_param->picture_coding_extension.bits.progressive_frame = 1;
825 pic_param->picture_coding_extension.bits.composite_display_flag = 0;
827 pic_param->user_data_length = 0;
831 mpeg2enc_alloc_va_resources(struct mpeg2enc_context *ctx)
833 VAEntrypoint *entrypoint_list;
834 VAConfigAttrib attrib_list[2];
836 int max_entrypoints, num_entrypoints, entrypoint;
837 int major_ver, minor_ver;
839 ctx->va_dpy = va_open_display();
840 va_status = vaInitialize(ctx->va_dpy,
843 CHECK_VASTATUS(va_status, "vaInitialize");
845 max_entrypoints = vaMaxNumEntrypoints(ctx->va_dpy);
846 entrypoint_list = malloc(max_entrypoints * sizeof(VAEntrypoint));
847 vaQueryConfigEntrypoints(ctx->va_dpy,
852 for (entrypoint = 0; entrypoint < num_entrypoints; entrypoint++) {
853 if (entrypoint_list[entrypoint] == VAEntrypointEncSlice)
857 free(entrypoint_list);
859 if (entrypoint == num_entrypoints) {
860 /* not find Slice entry point */
864 /* find out the format for the render target, and rate control mode */
865 attrib_list[0].type = VAConfigAttribRTFormat;
866 attrib_list[1].type = VAConfigAttribRateControl;
867 vaGetConfigAttributes(ctx->va_dpy,
869 VAEntrypointEncSlice,
873 if ((attrib_list[0].value & VA_RT_FORMAT_YUV420) == 0) {
874 /* not find desired YUV420 RT format */
878 if ((attrib_list[1].value & ctx->rate_control_mode) == 0) {
879 /* Can't find matched RC mode */
880 fprintf(stderr, "RC mode %d isn't found, exit\n", ctx->rate_control_mode);
884 attrib_list[0].value = VA_RT_FORMAT_YUV420; /* set to desired RT format */
885 attrib_list[1].value = ctx->rate_control_mode; /* set to desired RC mode */
887 va_status = vaCreateConfig(ctx->va_dpy,
889 VAEntrypointEncSlice,
893 CHECK_VASTATUS(va_status, "vaCreateConfig");
895 /* Create a context for this decode pipe */
896 va_status = vaCreateContext(ctx->va_dpy,
904 CHECK_VASTATUS(va_status, "vaCreateContext");
906 va_status = vaCreateSurfaces(ctx->va_dpy,
912 CHECK_VASTATUS(va_status, "vaCreateSurfaces");
916 mpeg2enc_init(struct mpeg2enc_context *ctx)
920 ctx->frame_data_buffer = (unsigned char *)malloc(ctx->frame_size);
921 ctx->seq_param_buf_id = VA_INVALID_ID;
922 ctx->pic_param_buf_id = VA_INVALID_ID;
923 ctx->packed_seq_header_param_buf_id = VA_INVALID_ID;
924 ctx->packed_seq_buf_id = VA_INVALID_ID;
925 ctx->packed_pic_header_param_buf_id = VA_INVALID_ID;
926 ctx->packed_pic_buf_id = VA_INVALID_ID;
927 ctx->codedbuf_buf_id = VA_INVALID_ID;
928 ctx->codedbuf_i_size = ctx->frame_size;
929 ctx->codedbuf_pb_size = 0;
930 ctx->next_display_order = 0;
931 ctx->next_type = VAEncPictureTypeIntra;
933 if (ctx->mode == MPEG2_MODE_I) {
934 ctx->intra_period = 1;
936 } else if (ctx->mode == MPEG2_MODE_IP) {
937 ctx->intra_period = 16;
940 ctx->intra_period = 16;
944 ctx->next_bframes = ctx->ip_period;
946 ctx->new_sequence = 1;
947 ctx->new_gop_header = 1;
948 ctx->gop_header_in_display_order = 0;
952 for (i = 0; i < MAX_SLICES; i++) {
953 ctx->slice_param_buf_id[i] = VA_INVALID_ID;
956 mpeg2enc_init_sequence_parameter(ctx, &ctx->seq_param);
957 mpeg2enc_init_picture_parameter(ctx, &ctx->pic_param);
958 mpeg2enc_alloc_va_resources(ctx);
961 ctx->current_input_surface = SID_INPUT_PICTURE_0;
962 ctx->current_upload_surface = SID_INPUT_PICTURE_1;
963 ctx->upload_thread_value = pthread_create(&ctx->upload_thread_id,
965 upload_yuv_to_surface,
970 mpeg2enc_time_code(VAEncSequenceParameterBufferMPEG2 *seq_param,
973 int fps = (int)(seq_param->frame_rate + 0.5);
975 int time_code_pictures, time_code_seconds, time_code_minutes, time_code_hours;
976 int drop_frame_flag = 0;
980 time_code_seconds = num_frames / fps;
981 time_code_pictures = num_frames % fps;
982 time_code |= time_code_pictures;
984 time_code_minutes = time_code_seconds / 60;
985 time_code_seconds = time_code_seconds % 60;
986 time_code |= (time_code_seconds << 6);
988 time_code_hours = time_code_minutes / 60;
989 time_code_minutes = time_code_minutes % 60;
991 time_code |= (1 << 12); /* marker_bit */
992 time_code |= (time_code_minutes << 13);
994 time_code_hours = time_code_hours % 24;
995 time_code |= (time_code_hours << 19);
997 time_code |= (drop_frame_flag << 24);
1006 mpeg2enc_update_sequence_parameter(struct mpeg2enc_context *ctx,
1007 VAEncPictureType picture_type,
1011 VAEncSequenceParameterBufferMPEG2 *seq_param = &ctx->seq_param;
1013 /* update the time_code info for the new GOP */
1014 if (ctx->new_gop_header) {
1015 seq_param->gop_header.bits.time_code = mpeg2enc_time_code(seq_param, display_order);
1020 mpeg2enc_update_picture_parameter(struct mpeg2enc_context *ctx,
1021 VAEncPictureType picture_type,
1025 VAEncPictureParameterBufferMPEG2 *pic_param = &ctx->pic_param;
1027 pic_param->picture_type = picture_type;
1028 pic_param->temporal_reference = (display_order - ctx->gop_header_in_display_order) & 0x3FF;
1029 pic_param->reconstructed_picture = surface_ids[SID_RECON_PICTURE];
1030 pic_param->forward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L0];
1031 pic_param->backward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L1];
1033 if (pic_param->picture_type == VAEncPictureTypeIntra) {
1034 pic_param->f_code[0][0] = 0xf;
1035 pic_param->f_code[0][1] = 0xf;
1036 pic_param->f_code[1][0] = 0xf;
1037 pic_param->f_code[1][1] = 0xf;
1038 pic_param->forward_reference_picture = VA_INVALID_SURFACE;
1039 pic_param->backward_reference_picture = VA_INVALID_SURFACE;
1041 } else if (pic_param->picture_type == VAEncPictureTypePredictive) {
1042 pic_param->f_code[0][0] = 0x1;
1043 pic_param->f_code[0][1] = 0x1;
1044 pic_param->f_code[1][0] = 0xf;
1045 pic_param->f_code[1][1] = 0xf;
1046 pic_param->forward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L0];
1047 pic_param->backward_reference_picture = VA_INVALID_SURFACE;
1048 } else if (pic_param->picture_type == VAEncPictureTypeBidirectional) {
1049 pic_param->f_code[0][0] = 0x1;
1050 pic_param->f_code[0][1] = 0x1;
1051 pic_param->f_code[1][0] = 0x1;
1052 pic_param->f_code[1][1] = 0x1;
1053 pic_param->forward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L0];
1054 pic_param->backward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L1];
1061 mpeg2enc_update_picture_parameter_buffer(struct mpeg2enc_context *ctx,
1062 VAEncPictureType picture_type,
1066 VAEncPictureParameterBufferMPEG2 *pic_param = &ctx->pic_param;
1069 /* update the coded buffer id */
1070 pic_param->coded_buf = ctx->codedbuf_buf_id;
1071 va_status = vaCreateBuffer(ctx->va_dpy,
1073 VAEncPictureParameterBufferType,
1077 &ctx->pic_param_buf_id);
1078 CHECK_VASTATUS(va_status, "vaCreateBuffer");
1082 mpeg2enc_update_slice_parameter(struct mpeg2enc_context *ctx, VAEncPictureType picture_type)
1084 VAEncSequenceParameterBufferMPEG2 *seq_param;
1085 VAEncPictureParameterBufferMPEG2 *pic_param;
1086 VAEncSliceParameterBufferMPEG2 *slice_param;
1088 int i, width_in_mbs, height_in_mbs;
1090 pic_param = &ctx->pic_param;
1091 assert(pic_param->picture_coding_extension.bits.q_scale_type == 0);
1093 seq_param = &ctx->seq_param;
1094 width_in_mbs = (seq_param->picture_width + 15) / 16;
1095 height_in_mbs = (seq_param->picture_height + 15) / 16;
1096 ctx->num_slice_groups = 1;
1098 for (i = 0; i < height_in_mbs; i++) {
1099 slice_param = &ctx->slice_param[i];
1100 slice_param->macroblock_address = i * width_in_mbs;
1101 slice_param->num_macroblocks = width_in_mbs;
1102 slice_param->is_intra_slice = (picture_type == VAEncPictureTypeIntra);
1103 slice_param->quantiser_scale_code = ctx->qp / 2;
1106 va_status = vaCreateBuffer(ctx->va_dpy,
1108 VAEncSliceParameterBufferType,
1109 sizeof(*slice_param),
1112 ctx->slice_param_buf_id);
1113 CHECK_VASTATUS(va_status, "vaCreateBuffer");;
1117 begin_picture(struct mpeg2enc_context *ctx,
1120 VAEncPictureType picture_type)
1124 VAEncPackedHeaderParameterBuffer packed_header_param_buffer;
1125 unsigned int length_in_bits;
1126 unsigned char *packed_seq_buffer = NULL, *packed_pic_buffer = NULL;
1128 if (ctx->upload_thread_value != 0) {
1129 fprintf(stderr, "FATAL error!!!\n");
1133 pthread_join(ctx->upload_thread_id, NULL);
1135 ctx->upload_thread_value = -1;
1136 tmp = ctx->current_input_surface;
1137 ctx->current_input_surface = ctx->current_upload_surface;
1138 ctx->current_upload_surface = tmp;
1140 mpeg2enc_update_sequence_parameter(ctx, picture_type, coded_order, display_order);
1141 mpeg2enc_update_picture_parameter(ctx, picture_type, coded_order, display_order);
1143 if (ctx->new_sequence || ctx->new_gop_header) {
1144 assert(picture_type == VAEncPictureTypeIntra);
1145 length_in_bits = build_packed_seq_buffer(ctx, &ctx->seq_param, &packed_seq_buffer);
1146 packed_header_param_buffer.type = VAEncPackedHeaderMPEG2_SPS;
1147 packed_header_param_buffer.has_emulation_bytes = 0;
1148 packed_header_param_buffer.bit_length = length_in_bits;
1149 va_status = vaCreateBuffer(ctx->va_dpy,
1151 VAEncPackedHeaderParameterBufferType,
1152 sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
1153 &ctx->packed_seq_header_param_buf_id);
1154 CHECK_VASTATUS(va_status,"vaCreateBuffer");
1156 va_status = vaCreateBuffer(ctx->va_dpy,
1158 VAEncPackedHeaderDataBufferType,
1159 (length_in_bits + 7) / 8, 1, packed_seq_buffer,
1160 &ctx->packed_seq_buf_id);
1161 CHECK_VASTATUS(va_status,"vaCreateBuffer");
1163 free(packed_seq_buffer);
1166 length_in_bits = build_packed_pic_buffer(&ctx->seq_param, &ctx->pic_param, &packed_pic_buffer);
1167 packed_header_param_buffer.type = VAEncPackedHeaderMPEG2_PPS;
1168 packed_header_param_buffer.has_emulation_bytes = 0;
1169 packed_header_param_buffer.bit_length = length_in_bits;
1171 va_status = vaCreateBuffer(ctx->va_dpy,
1173 VAEncPackedHeaderParameterBufferType,
1174 sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
1175 &ctx->packed_pic_header_param_buf_id);
1176 CHECK_VASTATUS(va_status,"vaCreateBuffer");
1178 va_status = vaCreateBuffer(ctx->va_dpy,
1180 VAEncPackedHeaderDataBufferType,
1181 (length_in_bits + 7) / 8, 1, packed_pic_buffer,
1182 &ctx->packed_pic_buf_id);
1183 CHECK_VASTATUS(va_status,"vaCreateBuffer");
1185 free(packed_pic_buffer);
1187 /* sequence parameter set */
1188 VAEncSequenceParameterBufferMPEG2 *seq_param = &ctx->seq_param;
1189 va_status = vaCreateBuffer(ctx->va_dpy,
1191 VAEncSequenceParameterBufferType,
1195 &ctx->seq_param_buf_id);
1196 CHECK_VASTATUS(va_status,"vaCreateBuffer");;
1198 /* slice parameter */
1199 mpeg2enc_update_slice_parameter(ctx, picture_type);
1205 mpeg2enc_render_picture(struct mpeg2enc_context *ctx)
1208 VABufferID va_buffers[16];
1209 unsigned int num_va_buffers = 0;
1211 va_buffers[num_va_buffers++] = ctx->seq_param_buf_id;
1212 va_buffers[num_va_buffers++] = ctx->pic_param_buf_id;
1214 if (ctx->packed_seq_header_param_buf_id != VA_INVALID_ID)
1215 va_buffers[num_va_buffers++] = ctx->packed_seq_header_param_buf_id;
1217 if (ctx->packed_seq_buf_id != VA_INVALID_ID)
1218 va_buffers[num_va_buffers++] = ctx->packed_seq_buf_id;
1220 if (ctx->packed_pic_header_param_buf_id != VA_INVALID_ID)
1221 va_buffers[num_va_buffers++] = ctx->packed_pic_header_param_buf_id;
1223 if (ctx->packed_pic_buf_id != VA_INVALID_ID)
1224 va_buffers[num_va_buffers++] = ctx->packed_pic_buf_id;
1226 va_status = vaBeginPicture(ctx->va_dpy,
1228 surface_ids[ctx->current_input_surface]);
1229 CHECK_VASTATUS(va_status,"vaBeginPicture");
1231 va_status = vaRenderPicture(ctx->va_dpy,
1235 CHECK_VASTATUS(va_status,"vaRenderPicture");
1237 va_status = vaRenderPicture(ctx->va_dpy,
1239 &ctx->slice_param_buf_id[0],
1240 ctx->num_slice_groups);
1241 CHECK_VASTATUS(va_status,"vaRenderPicture");
1243 va_status = vaEndPicture(ctx->va_dpy, ctx->context_id);
1244 CHECK_VASTATUS(va_status,"vaEndPicture");
1250 mpeg2enc_destroy_buffers(struct mpeg2enc_context *ctx, VABufferID *va_buffers, unsigned int num_va_buffers)
1255 for (i = 0; i < num_va_buffers; i++) {
1256 if (va_buffers[i] != VA_INVALID_ID) {
1257 va_status = vaDestroyBuffer(ctx->va_dpy, va_buffers[i]);
1258 CHECK_VASTATUS(va_status,"vaDestroyBuffer");
1259 va_buffers[i] = VA_INVALID_ID;
1267 end_picture(struct mpeg2enc_context *ctx, VAEncPictureType picture_type, int next_is_bpic)
1271 /* Prepare for next picture */
1272 tempID = surface_ids[SID_RECON_PICTURE];
1274 if (picture_type != VAEncPictureTypeBidirectional) {
1276 surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L1];
1277 surface_ids[SID_REFERENCE_PICTURE_L1] = tempID;
1279 surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L0];
1280 surface_ids[SID_REFERENCE_PICTURE_L0] = tempID;
1283 if (!next_is_bpic) {
1284 surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L0];
1285 surface_ids[SID_REFERENCE_PICTURE_L0] = surface_ids[SID_REFERENCE_PICTURE_L1];
1286 surface_ids[SID_REFERENCE_PICTURE_L1] = tempID;
1290 mpeg2enc_destroy_buffers(ctx, &ctx->seq_param_buf_id, 1);
1291 mpeg2enc_destroy_buffers(ctx, &ctx->pic_param_buf_id, 1);
1292 mpeg2enc_destroy_buffers(ctx, &ctx->packed_seq_header_param_buf_id, 1);
1293 mpeg2enc_destroy_buffers(ctx, &ctx->packed_seq_buf_id, 1);
1294 mpeg2enc_destroy_buffers(ctx, &ctx->packed_pic_header_param_buf_id, 1);
1295 mpeg2enc_destroy_buffers(ctx, &ctx->packed_pic_buf_id, 1);
1296 mpeg2enc_destroy_buffers(ctx, &ctx->slice_param_buf_id[0], ctx->num_slice_groups);
1297 mpeg2enc_destroy_buffers(ctx, &ctx->codedbuf_buf_id, 1);
1298 memset(ctx->slice_param, 0, sizeof(ctx->slice_param));
1299 ctx->num_slice_groups = 0;
1303 store_coded_buffer(struct mpeg2enc_context *ctx, VAEncPictureType picture_type)
1305 VACodedBufferSegment *coded_buffer_segment;
1306 unsigned char *coded_mem;
1307 int slice_data_length;
1309 VASurfaceStatus surface_status;
1312 va_status = vaSyncSurface(ctx->va_dpy, surface_ids[ctx->current_input_surface]);
1313 CHECK_VASTATUS(va_status,"vaSyncSurface");
1316 va_status = vaQuerySurfaceStatus(ctx->va_dpy, surface_ids[ctx->current_input_surface], &surface_status);
1317 CHECK_VASTATUS(va_status,"vaQuerySurfaceStatus");
1319 va_status = vaMapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id, (void **)(&coded_buffer_segment));
1320 CHECK_VASTATUS(va_status,"vaMapBuffer");
1321 coded_mem = coded_buffer_segment->buf;
1323 if (coded_buffer_segment->status & VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK) {
1324 if (picture_type == VAEncPictureTypeIntra)
1325 ctx->codedbuf_i_size *= 2;
1327 ctx->codedbuf_pb_size *= 2;
1329 vaUnmapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id);
1333 slice_data_length = coded_buffer_segment->size;
1336 w_items = fwrite(coded_mem, slice_data_length, 1, ctx->ofp);
1337 } while (w_items != 1);
1339 if (picture_type == VAEncPictureTypeIntra) {
1340 if (ctx->codedbuf_i_size > slice_data_length * 3 / 2) {
1341 ctx->codedbuf_i_size = slice_data_length * 3 / 2;
1344 if (ctx->codedbuf_pb_size < slice_data_length) {
1345 ctx->codedbuf_pb_size = slice_data_length;
1348 if (ctx->codedbuf_pb_size > slice_data_length * 3 / 2) {
1349 ctx->codedbuf_pb_size = slice_data_length * 3 / 2;
1353 vaUnmapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id);
1359 encode_picture(struct mpeg2enc_context *ctx,
1362 VAEncPictureType picture_type,
1364 int next_display_order)
1367 int ret = 0, codedbuf_size;
1369 begin_picture(ctx, coded_order, display_order, picture_type);
1372 /* upload YUV data to VA surface for next frame */
1373 if (next_display_order >= ctx->num_pictures)
1374 next_display_order = ctx->num_pictures - 1;
1376 fseek(ctx->ifp, ctx->frame_size * next_display_order, SEEK_SET);
1377 ctx->upload_thread_value = pthread_create(&ctx->upload_thread_id,
1379 upload_yuv_to_surface,
1384 mpeg2enc_destroy_buffers(ctx, &ctx->codedbuf_buf_id, 1);
1385 mpeg2enc_destroy_buffers(ctx, &ctx->pic_param_buf_id, 1);
1388 if (VAEncPictureTypeIntra == picture_type) {
1389 codedbuf_size = ctx->codedbuf_i_size;
1391 codedbuf_size = ctx->codedbuf_pb_size;
1395 va_status = vaCreateBuffer(ctx->va_dpy,
1397 VAEncCodedBufferType,
1398 codedbuf_size, 1, NULL,
1399 &ctx->codedbuf_buf_id);
1400 CHECK_VASTATUS(va_status,"vaCreateBuffer");
1402 /* picture parameter set */
1403 mpeg2enc_update_picture_parameter_buffer(ctx, picture_type, coded_order, display_order);
1405 mpeg2enc_render_picture(ctx);
1407 ret = store_coded_buffer(ctx, picture_type);
1410 end_picture(ctx, picture_type, next_is_bpic);
1414 update_next_frame_info(struct mpeg2enc_context *ctx,
1415 VAEncPictureType curr_type,
1416 int curr_coded_order,
1417 int curr_display_order)
1419 if (((curr_coded_order + 1) % ctx->intra_period) == 0) {
1420 ctx->next_type = VAEncPictureTypeIntra;
1421 ctx->next_display_order = curr_coded_order + 1;
1426 if (curr_type == VAEncPictureTypeIntra) {
1427 assert(curr_display_order == curr_coded_order);
1428 ctx->next_type = VAEncPictureTypePredictive;
1429 ctx->next_bframes = ctx->ip_period;
1430 ctx->next_display_order = curr_display_order + ctx->next_bframes + 1;
1431 } else if (curr_type == VAEncPictureTypePredictive) {
1432 if (ctx->ip_period == 0) {
1433 assert(curr_display_order == curr_coded_order);
1434 ctx->next_type = VAEncPictureTypePredictive;
1435 ctx->next_display_order = curr_display_order + 1;
1437 ctx->next_type = VAEncPictureTypeBidirectional;
1438 ctx->next_display_order = curr_display_order - ctx->next_bframes;
1439 ctx->next_bframes--;
1441 } else if (curr_type == VAEncPictureTypeBidirectional) {
1442 if (ctx->next_bframes == 0) {
1443 ctx->next_type = VAEncPictureTypePredictive;
1444 ctx->next_bframes = ctx->ip_period;
1445 ctx->next_display_order = curr_display_order + ctx->next_bframes + 2;
1447 ctx->next_type = VAEncPictureTypeBidirectional;
1448 ctx->next_display_order = curr_display_order + 1;
1449 ctx->next_bframes--;
1453 if (ctx->next_display_order >= ctx->num_pictures) {
1454 int rtmp = ctx->next_display_order - (ctx->num_pictures - 1);
1455 ctx->next_display_order = ctx->num_pictures - 1;
1456 ctx->next_bframes -= rtmp;
1461 mpeg2enc_run(struct mpeg2enc_context *ctx)
1463 int display_order = 0, coded_order = 0;
1464 VAEncPictureType type;
1466 ctx->new_sequence = 1;
1467 ctx->new_gop_header = 1;
1468 ctx->gop_header_in_display_order = display_order;
1470 while (coded_order < ctx->num_pictures) {
1471 type = ctx->next_type;
1472 display_order = ctx->next_display_order;
1473 /* follow the IPBxxBPBxxB mode */
1474 update_next_frame_info(ctx, type, coded_order, display_order);
1479 ctx->next_type == VAEncPictureTypeBidirectional,
1480 ctx->next_display_order);
1482 /* update gop_header */
1483 ctx->new_sequence = 0;
1484 ctx->new_gop_header = ctx->next_type == VAEncPictureTypeIntra;
1486 if (ctx->new_gop_header)
1487 ctx->gop_header_in_display_order += ctx->intra_period;
1491 fprintf(stderr, "\r %d/%d ...", coded_order, ctx->num_pictures);
1500 mpeg2enc_release_va_resources(struct mpeg2enc_context *ctx)
1502 vaDestroySurfaces(ctx->va_dpy, surface_ids, SID_NUMBER);
1503 vaDestroyContext(ctx->va_dpy, ctx->context_id);
1504 vaDestroyConfig(ctx->va_dpy, ctx->config_id);
1505 vaTerminate(ctx->va_dpy);
1506 va_close_display(ctx->va_dpy);
1510 mpeg2enc_end(struct mpeg2enc_context *ctx)
1512 pthread_join(ctx->upload_thread_id, NULL);
1513 mpeg2enc_release_va_resources(ctx);
1517 main(int argc, char *argv[])
1519 struct mpeg2enc_context ctx;
1520 struct timeval tpstart, tpend;
1523 gettimeofday(&tpstart, NULL);
1525 memset(&ctx, 0, sizeof(ctx));
1526 parse_args(&ctx, argc, argv);
1527 mpeg2enc_init(&ctx);
1531 gettimeofday(&tpend, NULL);
1532 timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) + tpend.tv_usec - tpstart.tv_usec;
1534 fprintf(stderr, "\ndone!\n");
1535 fprintf(stderr, "encode %d frames in %f secondes, FPS is %.1f\n", ctx.num_pictures, timeuse, ctx.num_pictures / timeuse);
1537 mpeg2enc_exit(&ctx, 0);