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
59 #define CHECK_VASTATUS(va_status, func) \
60 if (va_status != VA_STATUS_SUCCESS) { \
61 fprintf(stderr, "%s:%s (%d) failed, exit\n", __func__, func, __LINE__); \
65 #define INTRA_PERIOD 30
67 static int const picture_type_patter[][2] = {{VAEncPictureTypeIntra, 1},
68 {VAEncPictureTypePredictive, 3}, {VAEncPictureTypePredictive, 3},{VAEncPictureTypePredictive, 3},
69 {VAEncPictureTypePredictive, 3}, {VAEncPictureTypePredictive, 3},{VAEncPictureTypePredictive, 3},
70 {VAEncPictureTypePredictive, 3}, {VAEncPictureTypePredictive, 3},{VAEncPictureTypePredictive, 3},
71 {VAEncPictureTypePredictive, 2}};
73 struct mpeg2enc_context {
75 int rate_control_mode;
77 int mode; /* 0:I, 1:I/P, 2:I/P/B */
85 unsigned char *frame_data_buffer;
87 int bit_rate; /* in kbps */
91 VAEncSequenceParameterBufferMPEG2 seq_param;
92 VAEncPictureParameterBufferMPEG2 pic_param;
93 VAEncSliceParameterBufferMPEG2 slice_param[MAX_SLICES];
94 VAContextID context_id;
96 VABufferID seq_param_buf_id; /* Sequence level parameter */
97 VABufferID pic_param_buf_id; /* Picture level parameter */
98 VABufferID slice_param_buf_id[MAX_SLICES]; /* Slice level parameter, multil slices */
99 VABufferID codedbuf_buf_id; /* Output buffer, compressed data */
100 VABufferID packed_seq_header_param_buf_id;
101 VABufferID packed_seq_buf_id;
102 VABufferID packed_pic_header_param_buf_id;
103 VABufferID packed_pic_buf_id;
104 int num_slice_groups;
106 int codedbuf_pb_size;
109 pthread_t upload_thread_id;
110 int upload_thread_value;
111 int current_input_surface;
112 int current_upload_surface;
118 #define BITSTREAM_ALLOCATE_STEPPING 4096
121 unsigned int *buffer;
123 int max_size_in_dword;
126 typedef struct __bitstream bitstream;
129 swap32(unsigned int val)
131 unsigned char *pval = (unsigned char *)&val;
133 return ((pval[0] << 24) |
140 bitstream_start(bitstream *bs)
142 bs->max_size_in_dword = BITSTREAM_ALLOCATE_STEPPING;
143 bs->buffer = calloc(bs->max_size_in_dword * sizeof(int), 1);
148 bitstream_end(bitstream *bs)
150 int pos = (bs->bit_offset >> 5);
151 int bit_offset = (bs->bit_offset & 0x1f);
152 int bit_left = 32 - bit_offset;
155 bs->buffer[pos] = swap32((bs->buffer[pos] << bit_left));
160 bitstream_put_ui(bitstream *bs, unsigned int val, int size_in_bits)
162 int pos = (bs->bit_offset >> 5);
163 int bit_offset = (bs->bit_offset & 0x1f);
164 int bit_left = 32 - bit_offset;
169 if (size_in_bits < 32)
170 val &= ((1 << size_in_bits) - 1);
172 bs->bit_offset += size_in_bits;
174 if (bit_left > size_in_bits) {
175 bs->buffer[pos] = (bs->buffer[pos] << size_in_bits | val);
177 size_in_bits -= bit_left;
178 bs->buffer[pos] = (bs->buffer[pos] << bit_left) | (val >> size_in_bits);
179 bs->buffer[pos] = swap32(bs->buffer[pos]);
181 if (pos + 1 == bs->max_size_in_dword) {
182 bs->max_size_in_dword += BITSTREAM_ALLOCATE_STEPPING;
183 bs->buffer = realloc(bs->buffer, bs->max_size_in_dword * sizeof(unsigned int));
186 bs->buffer[pos + 1] = val;
191 bitstream_byte_aligning(bitstream *bs, int bit)
193 int bit_offset = (bs->bit_offset & 0x7);
194 int bit_left = 8 - bit_offset;
200 assert(bit == 0 || bit == 1);
203 new_val = (1 << bit_left) - 1;
207 bitstream_put_ui(bs, new_val, bit_left);
210 static struct mpeg2_frame_rate {
213 } frame_rate_tab[] = {
225 find_frame_rate_code(const VAEncSequenceParameterBufferMPEG2 *seq_param)
227 unsigned int delta = -1;
229 float frame_rate_value = seq_param->frame_rate *
230 (seq_param->sequence_extension.bits.frame_rate_extension_d + 1) /
231 (seq_param->sequence_extension.bits.frame_rate_extension_n + 1);
233 for (i = 0; i < sizeof(frame_rate_tab) / sizeof(frame_rate_tab[0]); i++) {
235 if (abs(1000 * frame_rate_tab[i].value - 1000 * frame_rate_value) < delta) {
236 code = frame_rate_tab[i].code;
237 delta = abs(1000 * frame_rate_tab[i].value - 1000 * frame_rate_value);
245 sps_rbsp(const VAEncSequenceParameterBufferMPEG2 *seq_param,
248 int frame_rate_code = find_frame_rate_code(seq_param);
250 bitstream_put_ui(bs, START_CODE_SEQ, 32);
251 bitstream_put_ui(bs, seq_param->picture_width, 12);
252 bitstream_put_ui(bs, seq_param->picture_height, 12);
253 bitstream_put_ui(bs, seq_param->aspect_ratio_information, 4);
254 bitstream_put_ui(bs, frame_rate_code, 4); /* frame_rate_code */
255 bitstream_put_ui(bs, (seq_param->bits_per_second + 399) / 400, 18); /* the low 18 bits of bit_rate */
256 bitstream_put_ui(bs, 1, 1); /* marker_bit */
257 bitstream_put_ui(bs, seq_param->vbv_buffer_size, 10);
258 bitstream_put_ui(bs, 0, 1); /* constraint_parameter_flag, always 0 for MPEG-2 */
259 bitstream_put_ui(bs, 0, 1); /* load_intra_quantiser_matrix */
260 bitstream_put_ui(bs, 0, 1); /* load_non_intra_quantiser_matrix */
262 bitstream_byte_aligning(bs, 0);
264 bitstream_put_ui(bs, START_CODE_EXT, 32);
265 bitstream_put_ui(bs, 1, 4); /* sequence_extension id */
266 bitstream_put_ui(bs, seq_param->sequence_extension.bits.profile_and_level_indication, 8);
267 bitstream_put_ui(bs, seq_param->sequence_extension.bits.progressive_sequence, 1);
268 bitstream_put_ui(bs, seq_param->sequence_extension.bits.chroma_format, 2);
269 bitstream_put_ui(bs, seq_param->picture_width >> 12, 2);
270 bitstream_put_ui(bs, seq_param->picture_height >> 12, 2);
271 bitstream_put_ui(bs, ((seq_param->bits_per_second + 399) / 400) >> 18, 12); /* bit_rate_extension */
272 bitstream_put_ui(bs, 1, 1); /* marker_bit */
273 bitstream_put_ui(bs, seq_param->vbv_buffer_size >> 10, 8);
274 bitstream_put_ui(bs, seq_param->sequence_extension.bits.low_delay, 1);
275 bitstream_put_ui(bs, seq_param->sequence_extension.bits.frame_rate_extension_n, 2);
276 bitstream_put_ui(bs, seq_param->sequence_extension.bits.frame_rate_extension_d, 5);
278 bitstream_byte_aligning(bs, 0);
280 bitstream_put_ui(bs, START_CODE_GOP, 32);
281 bitstream_put_ui(bs, seq_param->gop_header.bits.time_code, 25);
282 bitstream_put_ui(bs, seq_param->gop_header.bits.closed_gop, 1);
283 bitstream_put_ui(bs, seq_param->gop_header.bits.broken_link, 1);
285 bitstream_byte_aligning(bs, 0);
289 pps_rbsp(const VAEncSequenceParameterBufferMPEG2 *seq_param,
290 const VAEncPictureParameterBufferMPEG2 *pic_param,
296 if (seq_param->sequence_extension.bits.chroma_format == CHROMA_FORMAT_420)
297 chroma_420_type = pic_param->picture_coding_extension.bits.progressive_frame;
301 bitstream_put_ui(bs, START_CODE_PICUTRE, 32);
302 bitstream_put_ui(bs, pic_param->temporal_reference, 10);
304 pic_param->picture_type == VAEncPictureTypeIntra ? 1 :
305 pic_param->picture_type == VAEncPictureTypePredictive ? 2 : 3,
307 bitstream_put_ui(bs, 0xFFFF, 16); /* vbv_delay, always 0xFFFF */
309 if (pic_param->picture_type == VAEncPictureTypePredictive) {
310 bitstream_put_ui(bs, 0, 1); /* full_pel_forward_vector, always 0 for MPEG-2 */
311 bitstream_put_ui(bs, 7, 3); /* forward_f_code, always 7 for MPEG-2 */
314 if (pic_param->picture_type == VAEncPictureTypeBidirectional) {
315 bitstream_put_ui(bs, 0, 1); /* full_pel_backward_vector, always 0 for MPEG-2 */
316 bitstream_put_ui(bs, 7, 3); /* backward_f_code, always 7 for MPEG-2 */
319 bitstream_put_ui(bs, 0, 1); /* extra_bit_picture, 0 */
321 bitstream_byte_aligning(bs, 0);
323 bitstream_put_ui(bs, START_CODE_EXT, 32);
324 bitstream_put_ui(bs, 8, 4); /* Picture Coding Extension ID: 8 */
325 bitstream_put_ui(bs, pic_param->f_code[0][0], 4);
326 bitstream_put_ui(bs, pic_param->f_code[0][1], 4);
327 bitstream_put_ui(bs, pic_param->f_code[1][0], 4);
328 bitstream_put_ui(bs, pic_param->f_code[1][1], 4);
330 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.intra_dc_precision, 2);
331 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.picture_structure, 2);
332 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.top_field_first, 1);
333 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.frame_pred_frame_dct, 1);
334 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.concealment_motion_vectors, 1);
335 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.q_scale_type, 1);
336 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.intra_vlc_format, 1);
337 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.alternate_scan, 1);
338 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.repeat_first_field, 1);
339 bitstream_put_ui(bs, chroma_420_type, 1);
340 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.progressive_frame, 1);
341 bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.composite_display_flag, 1);
343 bitstream_byte_aligning(bs, 0);
345 if (pic_param->user_data_length) {
346 bitstream_put_ui(bs, START_CODE_USER, 32);
348 for (i = 0; i < pic_param->user_data_length; i++) {
349 bitstream_put_ui(bs, pic_param->user_data[i], 8);
352 bitstream_byte_aligning(bs, 0);
357 build_packed_pic_buffer(const VAEncSequenceParameterBufferMPEG2 *seq_param,
358 const VAEncPictureParameterBufferMPEG2 *pic_param,
359 unsigned char **header_buffer)
363 bitstream_start(&bs);
364 pps_rbsp(seq_param, pic_param, &bs);
367 *header_buffer = (unsigned char *)bs.buffer;
368 return bs.bit_offset;
372 build_packed_seq_buffer(const VAEncSequenceParameterBufferMPEG2 *seq_param,
373 unsigned char **header_buffer)
377 bitstream_start(&bs);
378 sps_rbsp(seq_param, &bs);
381 *header_buffer = (unsigned char *)bs.buffer;
382 return bs.bit_offset;
388 #define SID_INPUT_PICTURE_0 0
389 #define SID_INPUT_PICTURE_1 1
390 #define SID_REFERENCE_PICTURE_L0 2
391 #define SID_REFERENCE_PICTURE_L1 3
392 #define SID_RECON_PICTURE 4
393 #define SID_NUMBER SID_RECON_PICTURE + 1
395 static VASurfaceID surface_ids[SID_NUMBER];
398 * upload thread function
401 upload_yuv_to_surface(void *data)
403 struct mpeg2enc_context *ctx = data;
404 VAImage surface_image;
406 void *surface_p = NULL;
407 unsigned char *y_src, *u_src, *v_src;
408 unsigned char *y_dst, *u_dst, *v_dst;
409 int y_size = ctx->width * ctx->height;
410 int u_size = (ctx->width >> 1) * (ctx->height >> 1);
415 n_items = fread(ctx->frame_data_buffer, ctx->frame_size, 1, ctx->ifp);
416 } while (n_items != 1);
418 va_status = vaDeriveImage(ctx->va_dpy, surface_ids[ctx->current_upload_surface], &surface_image);
419 CHECK_VASTATUS(va_status,"vaDeriveImage");
421 vaMapBuffer(ctx->va_dpy, surface_image.buf, &surface_p);
422 assert(VA_STATUS_SUCCESS == va_status);
424 y_src = ctx->frame_data_buffer;
425 u_src = ctx->frame_data_buffer + y_size; /* UV offset for NV12 */
426 v_src = ctx->frame_data_buffer + y_size + u_size;
428 y_dst = surface_p + surface_image.offsets[0];
429 u_dst = surface_p + surface_image.offsets[1]; /* UV offset for NV12 */
430 v_dst = surface_p + surface_image.offsets[2];
433 for (row = 0; row < surface_image.height; row++) {
434 memcpy(y_dst, y_src, surface_image.width);
435 y_dst += surface_image.pitches[0];
439 if (surface_image.format.fourcc == VA_FOURCC_NV12) { /* UV plane */
440 for (row = 0; row < surface_image.height / 2; row++) {
441 for (col = 0; col < surface_image.width / 2; col++) {
442 u_dst[col * 2] = u_src[col];
443 u_dst[col * 2 + 1] = v_src[col];
446 u_dst += surface_image.pitches[1];
447 u_src += (ctx->width / 2);
448 v_src += (ctx->width / 2);
451 for (row = 0; row < surface_image.height / 2; row++) {
452 for (col = 0; col < surface_image.width / 2; col++) {
453 u_dst[col] = u_src[col];
454 v_dst[col] = v_src[col];
457 u_dst += surface_image.pitches[1];
458 v_dst += surface_image.pitches[2];
459 u_src += (ctx->width / 2);
460 v_src += (ctx->width / 2);
464 vaUnmapBuffer(ctx->va_dpy, surface_image.buf);
465 vaDestroyImage(ctx->va_dpy, surface_image.image_id);
471 mpeg2enc_exit(struct mpeg2enc_context *ctx, int exit_code)
473 if (ctx->frame_data_buffer) {
474 free(ctx->frame_data_buffer);
475 ctx->frame_data_buffer = NULL;
494 fprintf(stderr, "Usage: %s --help\n", program);
495 fprintf(stderr, "\t--help print this message\n");
496 fprintf(stderr, "Usage: %s <width> <height> <ifile> <ofile> [options]\n", program);
497 fprintf(stderr, "\t<width> specifies the frame width\n");
498 fprintf(stderr, "\t<height> specifies the frame height\n");
499 fprintf(stderr, "\t<ifile> specifies the I420/IYUV YUV file\n");
500 fprintf(stderr, "\t<ofile> specifies the encoded MPEG-2 file\n");
501 fprintf(stderr, "where options include:\n");
502 fprintf(stderr, "\t--cqp <QP> const qp mode with specified <QP>\n");
503 fprintf(stderr, "\t--fps <FPS> specify the frame rate\n");
504 fprintf(stderr, "\t--mode <MODE> specify the mode 0 (I), 1 (I/P) and 2 (I/P/B)\n");
508 parse_args(struct mpeg2enc_context *ctx, int argc, char **argv)
511 int option_index = 0;
513 static struct option long_options[] = {
514 {"help", no_argument, 0, 'h'},
515 {"cqp", required_argument, 0, 'c'},
516 {"fps", required_argument, 0, 'f'},
517 {"mode", required_argument, 0, 'm'},
521 if ((argc == 2 && strcmp(argv[1], "--help") == 0) ||
525 ctx->width = atoi(argv[1]);
526 ctx->height = atoi(argv[2]);
528 if (ctx->width <= 0 || ctx->height <= 0) {
529 fprintf(stderr, "<width> and <height> must be greater than 0\n");
533 ctx->ifp = fopen(argv[3], "rb");
535 if (ctx->ifp == NULL) {
536 fprintf(stderr, "Can't open the input file\n");
540 fseek(ctx->ifp, 0l, SEEK_END);
541 file_size = ftell(ctx->ifp);
542 ctx->frame_size = ctx->width * ctx->height * 3 / 2;
544 if ((file_size < ctx->frame_size) ||
545 (file_size % ctx->frame_size)) {
546 fprintf(stderr, "The input file size %ld isn't a multiple of the frame size %d\n", file_size, ctx->frame_size);
550 ctx->num_pictures = file_size / ctx->frame_size;
551 fseek(ctx->ifp, 0l, SEEK_SET);
553 ctx->ofp = fopen(argv[4], "wb");
555 if (ctx->ofp == NULL) {
556 fprintf(stderr, "Can't create the output file\n");
563 ctx->rate_control_mode = VA_RC_CQP;
568 while((c = getopt_long(argc, argv,
571 &option_index)) != -1) {
576 /* only support q_scale_type = 0 */
577 if (tmp > 62 || tmp < 2) {
578 fprintf(stderr, "Warning: QP must be in [2, 62]\n");
587 ctx->qp = tmp & 0xFE;
588 ctx->rate_control_mode = VA_RC_CQP;
596 fprintf(stderr, "Warning: FPS must be greater than 0\n");
600 ctx->rate_control_mode = VA_RC_CBR;
607 if (tmp < 0 || tmp > 2)
608 fprintf(stderr, "Waning: MODE must be 0, 1, or 2\n");
615 fprintf(stderr, "Error: unkown command options\n");
627 mpeg2enc_exit(ctx, 1);
634 mpeg2enc_init_sequence_parameter(struct mpeg2enc_context *ctx,
635 VAEncSequenceParameterBufferMPEG2 *seq_param)
637 seq_param->intra_period = ctx->intra_period;
638 seq_param->ip_period = 0; /* FIXME: ??? */
639 seq_param->picture_width = ctx->width;
640 seq_param->picture_height = ctx->height;
642 if (ctx->bit_rate > 0)
643 seq_param->bits_per_second = 1024 * ctx->bit_rate; /* use kbps as input */
645 seq_param->bits_per_second = 0x3FFFF * 400;
647 seq_param->frame_rate = ctx->fps;
648 seq_param->aspect_ratio_information = 1;
649 seq_param->vbv_buffer_size = 3; /* B = 16 * 1024 * vbv_buffer_size */
651 seq_param->sequence_extension.bits.profile_and_level_indication = 4 << 4 | 0x8; /* FIXME: Main/Main ??? */
652 seq_param->sequence_extension.bits.progressive_sequence = 1; /* progressive frame-pictures */
653 seq_param->sequence_extension.bits.chroma_format = CHROMA_FORMAT_420; /* 4:2:0 */
654 seq_param->sequence_extension.bits.low_delay = 0; /* FIXME */
655 seq_param->sequence_extension.bits.frame_rate_extension_n = 0;
656 seq_param->sequence_extension.bits.frame_rate_extension_d = 0;
658 seq_param->gop_header.bits.time_code = (1 << 12); /* bit12: marker_bit */
659 seq_param->gop_header.bits.closed_gop = 0;
660 seq_param->gop_header.bits.broken_link = 0;
664 mpeg2enc_init_picture_parameter(struct mpeg2enc_context *ctx,
665 VAEncPictureParameterBufferMPEG2 *pic_param)
667 pic_param->forward_reference_picture = VA_INVALID_ID;
668 pic_param->backward_reference_picture = VA_INVALID_ID;
669 pic_param->reconstructed_picture = VA_INVALID_ID;
670 pic_param->coded_buf = VA_INVALID_ID;
671 pic_param->picture_type = VAEncPictureTypeIntra;
673 pic_param->temporal_reference = 0;
674 pic_param->f_code[0][0] = 0xf;
675 pic_param->f_code[0][1] = 0xf;
676 pic_param->f_code[1][0] = 0xf;
677 pic_param->f_code[1][1] = 0xf;
679 pic_param->picture_coding_extension.bits.intra_dc_precision = 0; /* 8bits */
680 pic_param->picture_coding_extension.bits.picture_structure = 3; /* frame picture */
681 pic_param->picture_coding_extension.bits.top_field_first = 0;
682 pic_param->picture_coding_extension.bits.frame_pred_frame_dct = 1; /* FIXME */
683 pic_param->picture_coding_extension.bits.concealment_motion_vectors = 0;
684 pic_param->picture_coding_extension.bits.q_scale_type = 0;
685 pic_param->picture_coding_extension.bits.intra_vlc_format = 0;
686 pic_param->picture_coding_extension.bits.alternate_scan = 0;
687 pic_param->picture_coding_extension.bits.repeat_first_field = 0;
688 pic_param->picture_coding_extension.bits.progressive_frame = 1;
689 pic_param->picture_coding_extension.bits.composite_display_flag = 0;
691 pic_param->user_data_length = 0;
695 mpeg2enc_alloc_va_resources(struct mpeg2enc_context *ctx)
697 VAEntrypoint *entrypoint_list;
698 VAConfigAttrib attrib_list[2];
700 int max_entrypoints, num_entrypoints, entrypoint;
701 int major_ver, minor_ver;
703 ctx->va_dpy = va_open_display();
704 va_status = vaInitialize(ctx->va_dpy,
707 CHECK_VASTATUS(va_status, "vaInitialize");
709 max_entrypoints = vaMaxNumEntrypoints(ctx->va_dpy);
710 entrypoint_list = malloc(max_entrypoints * sizeof(VAEntrypoint));
711 vaQueryConfigEntrypoints(ctx->va_dpy,
712 VAProfileMPEG2Simple,
716 for (entrypoint = 0; entrypoint < num_entrypoints; entrypoint++) {
717 if (entrypoint_list[entrypoint] == VAEntrypointEncSlice)
721 free(entrypoint_list);
723 if (entrypoint == num_entrypoints) {
724 /* not find Slice entry point */
728 /* find out the format for the render target, and rate control mode */
729 attrib_list[0].type = VAConfigAttribRTFormat;
730 attrib_list[1].type = VAConfigAttribRateControl;
731 vaGetConfigAttributes(ctx->va_dpy,
732 VAProfileMPEG2Simple,
733 VAEntrypointEncSlice,
737 if ((attrib_list[0].value & VA_RT_FORMAT_YUV420) == 0) {
738 /* not find desired YUV420 RT format */
742 if ((attrib_list[1].value & ctx->rate_control_mode) == 0) {
743 /* Can't find matched RC mode */
744 fprintf(stderr, "RC mode %d isn't found, exit\n", ctx->rate_control_mode);
748 attrib_list[0].value = VA_RT_FORMAT_YUV420; /* set to desired RT format */
749 attrib_list[1].value = ctx->rate_control_mode; /* set to desired RC mode */
751 va_status = vaCreateConfig(ctx->va_dpy,
752 VAProfileMPEG2Simple,
753 VAEntrypointEncSlice,
757 CHECK_VASTATUS(va_status, "vaCreateConfig");
759 /* Create a context for this decode pipe */
760 va_status = vaCreateContext(ctx->va_dpy,
768 CHECK_VASTATUS(va_status, "vaCreateContext");
770 va_status = vaCreateSurfaces(ctx->va_dpy,
778 CHECK_VASTATUS(va_status, "vaCreateSurfaces");
782 mpeg2enc_init(struct mpeg2enc_context *ctx)
786 ctx->frame_data_buffer = (unsigned char *)malloc(ctx->frame_size);
787 ctx->seq_param_buf_id = VA_INVALID_ID;
788 ctx->pic_param_buf_id = VA_INVALID_ID;
789 ctx->packed_seq_header_param_buf_id = VA_INVALID_ID;
790 ctx->packed_seq_buf_id = VA_INVALID_ID;
791 ctx->packed_pic_header_param_buf_id = VA_INVALID_ID;
792 ctx->packed_pic_buf_id = VA_INVALID_ID;
793 ctx->codedbuf_buf_id = VA_INVALID_ID;
794 ctx->codedbuf_i_size = ctx->frame_size;
795 ctx->codedbuf_pb_size = 0;
796 ctx->intra_period = INTRA_PERIOD;
799 for (i = 0; i < MAX_SLICES; i++) {
800 ctx->slice_param_buf_id[i] = VA_INVALID_ID;
803 mpeg2enc_init_sequence_parameter(ctx, &ctx->seq_param);
804 mpeg2enc_init_picture_parameter(ctx, &ctx->pic_param);
805 mpeg2enc_alloc_va_resources(ctx);
808 ctx->current_input_surface = SID_INPUT_PICTURE_0;
809 ctx->current_upload_surface = SID_INPUT_PICTURE_1;
810 ctx->upload_thread_value = pthread_create(&ctx->upload_thread_id,
812 upload_yuv_to_surface,
820 mpeg2enc_update_picture_parameter(struct mpeg2enc_context *ctx,
821 VAEncPictureType picture_type,
825 VAEncPictureParameterBufferMPEG2 *pic_param;
829 pic_param = &ctx->pic_param;
830 pic_param->picture_type = picture_type;
831 pic_param->temporal_reference = display_order;
832 pic_param->reconstructed_picture = surface_ids[SID_RECON_PICTURE];
833 pic_param->forward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L0];
834 pic_param->backward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L1];
835 pic_param->coded_buf = ctx->codedbuf_buf_id;
837 va_status = vaCreateBuffer(ctx->va_dpy,
839 VAEncPictureParameterBufferType,
843 &ctx->pic_param_buf_id);
844 CHECK_VASTATUS(va_status, "vaCreateBuffer");
848 mpeg2enc_update_slice_parameter(struct mpeg2enc_context *ctx, VAEncPictureType picture_type)
850 VAEncSequenceParameterBufferMPEG2 *seq_param;
851 VAEncPictureParameterBufferMPEG2 *pic_param;
852 VAEncSliceParameterBufferMPEG2 *slice_param;
854 int i, width_in_mbs, height_in_mbs;
856 pic_param = &ctx->pic_param;
857 assert(pic_param->picture_coding_extension.bits.q_scale_type == 0);
859 seq_param = &ctx->seq_param;
860 width_in_mbs = (seq_param->picture_width + 15) / 16;
861 height_in_mbs = (seq_param->picture_height + 15) / 16;
862 ctx->num_slice_groups = 1;
864 for (i = 0; i < height_in_mbs; i++) {
865 slice_param = &ctx->slice_param[i];
866 slice_param->macroblock_address = i * width_in_mbs;
867 slice_param->num_macroblocks = width_in_mbs;
868 slice_param->is_intra_slice = (picture_type == VAEncPictureTypeIntra);
869 slice_param->quantiser_scale_code = ctx->qp / 2;
872 va_status = vaCreateBuffer(ctx->va_dpy,
874 VAEncSliceParameterBufferType,
875 sizeof(*slice_param),
878 ctx->slice_param_buf_id);
879 CHECK_VASTATUS(va_status, "vaCreateBuffer");;
883 begin_picture(struct mpeg2enc_context *ctx,
886 VAEncPictureType picture_type)
890 VAEncPackedHeaderParameterBuffer packed_header_param_buffer;
891 unsigned int length_in_bits;
892 unsigned char *packed_seq_buffer = NULL, *packed_pic_buffer = NULL;
894 if (ctx->upload_thread_value != 0) {
895 fprintf(stderr, "FATAL error!!!\n");
899 pthread_join(ctx->upload_thread_id, NULL);
901 ctx->upload_thread_value = -1;
902 tmp = ctx->current_input_surface;
903 ctx->current_input_surface = ctx->current_upload_surface;
904 ctx->current_upload_surface = tmp;
906 if (coded_order == 0) {
907 assert(picture_type == VAEncPictureTypeIntra);
908 length_in_bits = build_packed_seq_buffer(&ctx->seq_param, &packed_seq_buffer);
909 packed_header_param_buffer.type = VAEncPackedHeaderMPEG2_SPS;
910 packed_header_param_buffer.has_emulation_bytes = 0;
911 packed_header_param_buffer.bit_length = length_in_bits;
912 va_status = vaCreateBuffer(ctx->va_dpy,
914 VAEncPackedHeaderParameterBufferType,
915 sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
916 &ctx->packed_seq_header_param_buf_id);
917 CHECK_VASTATUS(va_status,"vaCreateBuffer");
919 va_status = vaCreateBuffer(ctx->va_dpy,
921 VAEncPackedHeaderDataBufferType,
922 (length_in_bits + 7) / 8, 1, packed_seq_buffer,
923 &ctx->packed_seq_buf_id);
924 CHECK_VASTATUS(va_status,"vaCreateBuffer");
926 free(packed_seq_buffer);
929 length_in_bits = build_packed_pic_buffer(&ctx->seq_param, &ctx->pic_param, &packed_pic_buffer);
930 packed_header_param_buffer.type = VAEncPackedHeaderMPEG2_PPS;
931 packed_header_param_buffer.has_emulation_bytes = 0;
932 packed_header_param_buffer.bit_length = length_in_bits;
934 va_status = vaCreateBuffer(ctx->va_dpy,
936 VAEncPackedHeaderParameterBufferType,
937 sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
938 &ctx->packed_pic_header_param_buf_id);
939 CHECK_VASTATUS(va_status,"vaCreateBuffer");
941 va_status = vaCreateBuffer(ctx->va_dpy,
943 VAEncPackedHeaderDataBufferType,
944 (length_in_bits + 7) / 8, 1, packed_pic_buffer,
945 &ctx->packed_pic_buf_id);
946 CHECK_VASTATUS(va_status,"vaCreateBuffer");
948 free(packed_pic_buffer);
950 /* sequence parameter set */
951 VAEncSequenceParameterBufferMPEG2 *seq_param = &ctx->seq_param;
952 va_status = vaCreateBuffer(ctx->va_dpy,
954 VAEncSequenceParameterBufferType,
958 &ctx->seq_param_buf_id);
959 CHECK_VASTATUS(va_status,"vaCreateBuffer");;
961 /* slice parameter */
962 mpeg2enc_update_slice_parameter(ctx, picture_type);
968 mpeg2enc_render_picture(struct mpeg2enc_context *ctx)
971 VABufferID va_buffers[16];
972 unsigned int num_va_buffers = 0;
974 va_buffers[num_va_buffers++] = ctx->seq_param_buf_id;
975 va_buffers[num_va_buffers++] = ctx->pic_param_buf_id;
977 if (ctx->packed_seq_header_param_buf_id != VA_INVALID_ID)
978 va_buffers[num_va_buffers++] = ctx->packed_seq_header_param_buf_id;
980 if (ctx->packed_seq_buf_id != VA_INVALID_ID)
981 va_buffers[num_va_buffers++] = ctx->packed_seq_buf_id;
983 if (ctx->packed_pic_header_param_buf_id != VA_INVALID_ID)
984 va_buffers[num_va_buffers++] = ctx->packed_pic_header_param_buf_id;
986 if (ctx->packed_pic_buf_id != VA_INVALID_ID)
987 va_buffers[num_va_buffers++] = ctx->packed_pic_buf_id;
989 va_status = vaBeginPicture(ctx->va_dpy,
991 surface_ids[ctx->current_input_surface]);
992 CHECK_VASTATUS(va_status,"vaBeginPicture");
994 va_status = vaRenderPicture(ctx->va_dpy,
998 CHECK_VASTATUS(va_status,"vaRenderPicture");
1000 va_status = vaRenderPicture(ctx->va_dpy,
1002 &ctx->slice_param_buf_id[0],
1003 ctx->num_slice_groups);
1004 CHECK_VASTATUS(va_status,"vaRenderPicture");
1006 va_status = vaEndPicture(ctx->va_dpy, ctx->context_id);
1007 CHECK_VASTATUS(va_status,"vaEndPicture");
1013 mpeg2enc_destroy_buffers(struct mpeg2enc_context *ctx, VABufferID *va_buffers, unsigned int num_va_buffers)
1018 for (i = 0; i < num_va_buffers; i++) {
1019 if (va_buffers[i] != VA_INVALID_ID) {
1020 va_status = vaDestroyBuffer(ctx->va_dpy, va_buffers[i]);
1021 CHECK_VASTATUS(va_status,"vaDestroyBuffer");
1022 va_buffers[i] = VA_INVALID_ID;
1030 end_picture(struct mpeg2enc_context *ctx, VAEncPictureType picture_type, int next_is_bpic)
1034 /* Prepare for next picture */
1035 tempID = surface_ids[SID_RECON_PICTURE];
1037 if (picture_type != VAEncPictureTypeBidirectional) {
1039 surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L1];
1040 surface_ids[SID_REFERENCE_PICTURE_L1] = tempID;
1042 surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L0];
1043 surface_ids[SID_REFERENCE_PICTURE_L0] = tempID;
1046 if (!next_is_bpic) {
1047 surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L0];
1048 surface_ids[SID_REFERENCE_PICTURE_L0] = surface_ids[SID_REFERENCE_PICTURE_L1];
1049 surface_ids[SID_REFERENCE_PICTURE_L1] = tempID;
1053 mpeg2enc_destroy_buffers(ctx, &ctx->seq_param_buf_id, 1);
1054 mpeg2enc_destroy_buffers(ctx, &ctx->pic_param_buf_id, 1);
1055 mpeg2enc_destroy_buffers(ctx, &ctx->packed_seq_header_param_buf_id, 1);
1056 mpeg2enc_destroy_buffers(ctx, &ctx->packed_seq_buf_id, 1);
1057 mpeg2enc_destroy_buffers(ctx, &ctx->packed_pic_header_param_buf_id, 1);
1058 mpeg2enc_destroy_buffers(ctx, &ctx->packed_pic_buf_id, 1);
1059 mpeg2enc_destroy_buffers(ctx, &ctx->slice_param_buf_id[0], ctx->num_slice_groups);
1060 mpeg2enc_destroy_buffers(ctx, &ctx->codedbuf_buf_id, 1);
1061 memset(ctx->slice_param, 0, sizeof(ctx->slice_param));
1062 ctx->num_slice_groups = 0;
1066 store_coded_buffer(struct mpeg2enc_context *ctx, VAEncPictureType picture_type)
1068 VACodedBufferSegment *coded_buffer_segment;
1069 unsigned char *coded_mem;
1070 int slice_data_length;
1072 VASurfaceStatus surface_status;
1075 va_status = vaSyncSurface(ctx->va_dpy, surface_ids[ctx->current_input_surface]);
1076 CHECK_VASTATUS(va_status,"vaSyncSurface");
1079 va_status = vaQuerySurfaceStatus(ctx->va_dpy, surface_ids[ctx->current_input_surface], &surface_status);
1080 CHECK_VASTATUS(va_status,"vaQuerySurfaceStatus");
1082 va_status = vaMapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id, (void **)(&coded_buffer_segment));
1083 CHECK_VASTATUS(va_status,"vaMapBuffer");
1084 coded_mem = coded_buffer_segment->buf;
1086 if (coded_buffer_segment->status & VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK) {
1087 if (picture_type == VAEncPictureTypeIntra)
1088 ctx->codedbuf_i_size *= 2;
1090 ctx->codedbuf_pb_size *= 2;
1092 vaUnmapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id);
1096 slice_data_length = coded_buffer_segment->size;
1099 w_items = fwrite(coded_mem, slice_data_length, 1, ctx->ofp);
1100 } while (w_items != 1);
1102 if (picture_type == VAEncPictureTypeIntra) {
1103 if (ctx->codedbuf_i_size > slice_data_length * 3 / 2) {
1104 ctx->codedbuf_i_size = slice_data_length * 3 / 2;
1107 if (ctx->codedbuf_pb_size < slice_data_length) {
1108 ctx->codedbuf_pb_size = slice_data_length;
1111 if (ctx->codedbuf_pb_size > slice_data_length * 3 / 2) {
1112 ctx->codedbuf_pb_size = slice_data_length * 3 / 2;
1116 vaUnmapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id);
1122 encode_picture(struct mpeg2enc_context *ctx,
1125 VAEncPictureType picture_type,
1127 int next_display_order)
1130 int ret = 0, codedbuf_size;
1132 begin_picture(ctx, coded_order, display_order, picture_type);
1135 /* upload YUV data to VA surface for next frame */
1136 if (next_display_order >= ctx->num_pictures)
1137 next_display_order = ctx->num_pictures - 1;
1139 fseek(ctx->ifp, ctx->frame_size * next_display_order, SEEK_SET);
1140 ctx->upload_thread_value = pthread_create(&ctx->upload_thread_id,
1142 upload_yuv_to_surface,
1147 mpeg2enc_destroy_buffers(ctx, &ctx->codedbuf_buf_id, 1);
1148 mpeg2enc_destroy_buffers(ctx, &ctx->pic_param_buf_id, 1);
1151 if (VAEncPictureTypeIntra == picture_type) {
1152 codedbuf_size = ctx->codedbuf_i_size;
1154 codedbuf_size = ctx->codedbuf_pb_size;
1158 va_status = vaCreateBuffer(ctx->va_dpy,
1160 VAEncCodedBufferType,
1161 codedbuf_size, 1, NULL,
1162 &ctx->codedbuf_buf_id);
1163 CHECK_VASTATUS(va_status,"vaCreateBuffer");
1165 /* picture parameter set */
1166 mpeg2enc_update_picture_parameter(ctx, picture_type, coded_order, display_order);
1168 mpeg2enc_render_picture(ctx);
1170 ret = store_coded_buffer(ctx, picture_type);
1173 end_picture(ctx, picture_type, next_is_bpic);
1177 encode_pb_pictures(struct mpeg2enc_context *ctx,
1188 VAEncPictureTypePredictive,
1192 for( i = 0; i < nbframes - 1; i++) {
1196 VAEncPictureTypeBidirectional,
1204 VAEncPictureTypeBidirectional,
1210 mpeg2enc_run(struct mpeg2enc_context *ctx)
1212 int display_order = 0, coded_order = 0;
1213 int i_frame_only = 1, i_p_frame_only = 1;
1215 for (display_order = 0; display_order < ctx->num_pictures;) {
1220 VAEncPictureTypeIntra,
1225 } else if (i_p_frame_only) {
1226 if ((display_order % ctx->intra_period) == 0) {
1230 VAEncPictureTypeIntra,
1239 VAEncPictureTypePredictive,
1245 } else { // follow the i,p,b pattern
1246 static int fcurrent = 0;
1249 fcurrent = fcurrent % (sizeof(picture_type_patter)/sizeof(int[2]));
1250 fnext = (fcurrent+1) % (sizeof(picture_type_patter)/sizeof(int[2]));
1252 if ( picture_type_patter[fcurrent][0] == VAEncPictureTypeIntra ) {
1256 VAEncPictureTypeIntra,
1258 display_order + picture_type_patter[fnext][1]);
1262 encode_pb_pictures(ctx,
1265 picture_type_patter[fcurrent][1] - 1,
1266 display_order + picture_type_patter[fcurrent][1] + picture_type_patter[fnext][1] - 1);
1267 display_order += picture_type_patter[fcurrent][1];
1274 fprintf(stderr, "\r %d/%d ...", display_order + 1, ctx->num_pictures);
1283 mpeg2enc_release_va_resources(struct mpeg2enc_context *ctx)
1285 vaDestroySurfaces(ctx->va_dpy, surface_ids, SID_NUMBER);
1286 vaDestroyContext(ctx->va_dpy, ctx->context_id);
1287 vaDestroyConfig(ctx->va_dpy, ctx->config_id);
1288 vaTerminate(ctx->va_dpy);
1289 va_close_display(ctx->va_dpy);
1293 mpeg2enc_end(struct mpeg2enc_context *ctx)
1295 pthread_join(ctx->upload_thread_id, NULL);
1296 mpeg2enc_release_va_resources(ctx);
1300 main(int argc, char *argv[])
1302 struct mpeg2enc_context ctx;
1303 struct timeval tpstart, tpend;
1306 gettimeofday(&tpstart, NULL);
1308 memset(&ctx, 0, sizeof(ctx));
1309 parse_args(&ctx, argc, argv);
1310 mpeg2enc_init(&ctx);
1314 gettimeofday(&tpend, NULL);
1315 timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) + tpend.tv_usec - tpstart.tv_usec;
1317 fprintf(stderr, "\ndone!\n");
1318 fprintf(stderr, "encode %d frames in %f secondes, FPS is %.1f\n", ctx.num_pictures, timeuse, ctx.num_pictures / timeuse);
1320 mpeg2enc_exit(&ctx, 0);