test/encode/mpeg2enc.c

   1 /*
   2  * Copyright (c) 2012 Intel Corporation. All Rights Reserved.
   3  *
   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:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  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.
  23  */
  24 /*
  25  * Simple MPEG-2 encoder based on libVA.
  26  *
  27  */
  28
  29 #include "sysdeps.h"
  30
  31 #include <getopt.h>
  32 #include <unistd.h>
  33
  34 #include <sys/time.h>
  35 #include <sys/types.h>
  36 #include <fcntl.h>
  37 #include <time.h>
  38 #include <pthread.h>
  39
  40 #include <va/va.h>
  41 #include <va/va_enc_mpeg2.h>
  42
  43 #include "va_display.h"
  44
  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
  51
  52 #define CHROMA_FORMAT_RESERVED  0
  53 #define CHROMA_FORMAT_420       1
  54 #define CHROMA_FORMAT_422       2
  55 #define CHROMA_FORMAT_444       3
  56
  57 #define MAX_SLICES              128
  58
  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__); \
  62         exit(1);                                                        \
  63     }
  64
  65 #define INTRA_PERIOD            30
  66
  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}};
  72
  73 struct mpeg2enc_context {
  74     /* args */
  75     int rate_control_mode;
  76     int fps;
  77     int width;
  78     int height;
  79     int frame_size;
  80     int num_pictures;
  81     int qp;
  82     FILE *ifp;
  83     FILE *ofp;
  84     unsigned char *frame_data_buffer;
  85     int intra_period;
  86     int bit_rate; /* in kbps */
  87
  88     /* VA resource */
  89     VADisplay va_dpy;
  90     VAEncSequenceParameterBufferMPEG2 seq_param;
  91     VAEncPictureParameterBufferMPEG2 pic_param;
  92     VAEncSliceParameterBufferMPEG2 slice_param[MAX_SLICES];
  93     VAContextID context_id;
  94     VAConfigID config_id;
  95     VABufferID seq_param_buf_id;                /* Sequence level parameter */
  96     VABufferID pic_param_buf_id;                /* Picture level parameter */
  97     VABufferID slice_param_buf_id[MAX_SLICES];  /* Slice level parameter, multil slices */
  98     VABufferID codedbuf_buf_id;                 /* Output buffer, compressed data */
  99     VABufferID packed_seq_header_param_buf_id;
 100     VABufferID packed_seq_buf_id;
 101     VABufferID packed_pic_header_param_buf_id;
 102     VABufferID packed_pic_buf_id;
 103     int num_slice_groups;
 104     int codedbuf_i_size;
 105     int codedbuf_pb_size;
 106
 107     /* thread */
 108     pthread_t upload_thread_id;
 109     int upload_thread_value;
 110     int current_input_surface;
 111     int current_upload_surface;
 112 };
 113
 114 /*
 115  * mpeg2enc helpers
 116  */
 117 #define BITSTREAM_ALLOCATE_STEPPING     4096
 118
 119 struct __bitstream {
 120     unsigned int *buffer;
 121     int bit_offset;
 122     int max_size_in_dword;
 123 };
 124
 125 typedef struct __bitstream bitstream;
 126
 127 static unsigned int
 128 swap32(unsigned int val)
 129 {
 130     unsigned char *pval = (unsigned char *)&val;
 131
 132     return ((pval[0] << 24)     |
 133             (pval[1] << 16)     |
 134             (pval[2] << 8)      |
 135             (pval[3] << 0));
 136 }
 137
 138 static void
 139 bitstream_start(bitstream *bs)
 140 {
 141     bs->max_size_in_dword = BITSTREAM_ALLOCATE_STEPPING;
 142     bs->buffer = calloc(bs->max_size_in_dword * sizeof(int), 1);
 143     bs->bit_offset = 0;
 144 }
 145
 146 static void
 147 bitstream_end(bitstream *bs)
 148 {
 149     int pos = (bs->bit_offset >> 5);
 150     int bit_offset = (bs->bit_offset & 0x1f);
 151     int bit_left = 32 - bit_offset;
 152
 153     if (bit_offset) {
 154         bs->buffer[pos] = swap32((bs->buffer[pos] << bit_left));
 155     }
 156 }
 157
 158 static void
 159 bitstream_put_ui(bitstream *bs, unsigned int val, int size_in_bits)
 160 {
 161     int pos = (bs->bit_offset >> 5);
 162     int bit_offset = (bs->bit_offset & 0x1f);
 163     int bit_left = 32 - bit_offset;
 164
 165     if (!size_in_bits)
 166         return;
 167
 168     if (size_in_bits < 32)
 169         val &= ((1 << size_in_bits) - 1);
 170
 171     bs->bit_offset += size_in_bits;
 172
 173     if (bit_left > size_in_bits) {
 174         bs->buffer[pos] = (bs->buffer[pos] << size_in_bits | val);
 175     } else {
 176         size_in_bits -= bit_left;
 177         bs->buffer[pos] = (bs->buffer[pos] << bit_left) | (val >> size_in_bits);
 178         bs->buffer[pos] = swap32(bs->buffer[pos]);
 179
 180         if (pos + 1 == bs->max_size_in_dword) {
 181             bs->max_size_in_dword += BITSTREAM_ALLOCATE_STEPPING;
 182             bs->buffer = realloc(bs->buffer, bs->max_size_in_dword * sizeof(unsigned int));
 183         }
 184
 185         bs->buffer[pos + 1] = val;
 186     }
 187 }
 188
 189 static void
 190 bitstream_byte_aligning(bitstream *bs, int bit)
 191 {
 192     int bit_offset = (bs->bit_offset & 0x7);
 193     int bit_left = 8 - bit_offset;
 194     int new_val;
 195
 196     if (!bit_offset)
 197         return;
 198
 199     assert(bit == 0 || bit == 1);
 200
 201     if (bit)
 202         new_val = (1 << bit_left) - 1;
 203     else
 204         new_val = 0;
 205
 206     bitstream_put_ui(bs, new_val, bit_left);
 207 }
 208
 209 static struct mpeg2_frame_rate {
 210     int code;
 211     float value;
 212 } frame_rate_tab[] = {
 213     {1, 23.976},
 214     {2, 24.0},
 215     {3, 25.0},
 216     {4, 29.97},
 217     {5, 30},
 218     {6, 50},
 219     {7, 59.94},
 220     {8, 60}
 221 };
 222
 223 static int
 224 find_frame_rate_code(const VAEncSequenceParameterBufferMPEG2 *seq_param)
 225 {
 226     unsigned int delta = -1;
 227     int code = 1, i;
 228     float frame_rate_value = seq_param->frame_rate *
 229         (seq_param->sequence_extension.bits.frame_rate_extension_d + 1) /
 230         (seq_param->sequence_extension.bits.frame_rate_extension_n + 1);
 231
 232     for (i = 0; i < sizeof(frame_rate_tab) / sizeof(frame_rate_tab[0]); i++) {
 233
 234         if (abs(1000 * frame_rate_tab[i].value - 1000 * frame_rate_value) < delta) {
 235             code = frame_rate_tab[i].code;
 236             delta = abs(1000 * frame_rate_tab[i].value - 1000 * frame_rate_value);
 237         }
 238     }
 239
 240     return code;
 241 }
 242
 243 static void
 244 sps_rbsp(const VAEncSequenceParameterBufferMPEG2 *seq_param,
 245          bitstream *bs)
 246 {
 247     int frame_rate_code = find_frame_rate_code(seq_param);
 248
 249     bitstream_put_ui(bs, START_CODE_SEQ, 32);
 250     bitstream_put_ui(bs, seq_param->picture_width, 12);
 251     bitstream_put_ui(bs, seq_param->picture_height, 12);
 252     bitstream_put_ui(bs, seq_param->aspect_ratio_information, 4);
 253     bitstream_put_ui(bs, frame_rate_code, 4); /* frame_rate_code */
 254     bitstream_put_ui(bs, (seq_param->bits_per_second + 399) / 400, 18); /* the low 18 bits of bit_rate */
 255     bitstream_put_ui(bs, 1, 1); /* marker_bit */
 256     bitstream_put_ui(bs, seq_param->vbv_buffer_size, 10);
 257     bitstream_put_ui(bs, 0, 1); /* constraint_parameter_flag, always 0 for MPEG-2 */
 258     bitstream_put_ui(bs, 0, 1); /* load_intra_quantiser_matrix */
 259     bitstream_put_ui(bs, 0, 1); /* load_non_intra_quantiser_matrix */
 260
 261     bitstream_byte_aligning(bs, 0);
 262
 263     bitstream_put_ui(bs, START_CODE_EXT, 32);
 264     bitstream_put_ui(bs, 1, 4); /* sequence_extension id */
 265     bitstream_put_ui(bs, seq_param->sequence_extension.bits.profile_and_level_indication, 8);
 266     bitstream_put_ui(bs, seq_param->sequence_extension.bits.progressive_sequence, 1);
 267     bitstream_put_ui(bs, seq_param->sequence_extension.bits.chroma_format, 2);
 268     bitstream_put_ui(bs, seq_param->picture_width >> 12, 2);
 269     bitstream_put_ui(bs, seq_param->picture_height >> 12, 2);
 270     bitstream_put_ui(bs, ((seq_param->bits_per_second + 399) / 400) >> 18, 12); /* bit_rate_extension */
 271     bitstream_put_ui(bs, 1, 1); /* marker_bit */
 272     bitstream_put_ui(bs, seq_param->vbv_buffer_size >> 10, 8);
 273     bitstream_put_ui(bs, seq_param->sequence_extension.bits.low_delay, 1);
 274     bitstream_put_ui(bs, seq_param->sequence_extension.bits.frame_rate_extension_n, 2);
 275     bitstream_put_ui(bs, seq_param->sequence_extension.bits.frame_rate_extension_d, 5);
 276
 277     bitstream_byte_aligning(bs, 0);
 278
 279     bitstream_put_ui(bs, START_CODE_GOP, 32);
 280     bitstream_put_ui(bs, seq_param->gop_header.bits.time_code, 25);
 281     bitstream_put_ui(bs, seq_param->gop_header.bits.closed_gop, 1);
 282     bitstream_put_ui(bs, seq_param->gop_header.bits.broken_link, 1);
 283
 284     bitstream_byte_aligning(bs, 0);
 285 }
 286
 287 static void
 288 pps_rbsp(const VAEncSequenceParameterBufferMPEG2 *seq_param,
 289          const VAEncPictureParameterBufferMPEG2 *pic_param,
 290          bitstream *bs)
 291 {
 292     int i;
 293     int chroma_420_type;
 294
 295     if (seq_param->sequence_extension.bits.chroma_format == CHROMA_FORMAT_420)
 296         chroma_420_type = pic_param->picture_coding_extension.bits.progressive_frame;
 297     else
 298         chroma_420_type = 0;
 299
 300     bitstream_put_ui(bs, START_CODE_PICUTRE, 32);
 301     bitstream_put_ui(bs, pic_param->temporal_reference, 10);
 302     bitstream_put_ui(bs,
 303                      pic_param->picture_type == VAEncPictureTypeIntra ? 1 :
 304                      pic_param->picture_type == VAEncPictureTypePredictive ? 2 : 3,
 305                      3);
 306     bitstream_put_ui(bs, 0xFFFF, 16); /* vbv_delay, always 0xFFFF */
 307
 308     if (pic_param->picture_type == VAEncPictureTypePredictive) {
 309         bitstream_put_ui(bs, 0, 1); /* full_pel_forward_vector, always 0 for MPEG-2 */
 310         bitstream_put_ui(bs, 7, 3); /* forward_f_code, always 7 for MPEG-2 */
 311     }
 312
 313     if (pic_param->picture_type == VAEncPictureTypeBidirectional) {
 314         bitstream_put_ui(bs, 0, 1); /* full_pel_backward_vector, always 0 for MPEG-2 */
 315         bitstream_put_ui(bs, 7, 3); /* backward_f_code, always 7 for MPEG-2 */
 316     }
 317
 318     bitstream_put_ui(bs, 0, 1); /* extra_bit_picture, 0 */
 319
 320     bitstream_byte_aligning(bs, 0);
 321
 322     bitstream_put_ui(bs, START_CODE_EXT, 32);
 323     bitstream_put_ui(bs, 8, 4); /* Picture Coding Extension ID: 8 */
 324     bitstream_put_ui(bs, pic_param->f_code[0][0], 4);
 325     bitstream_put_ui(bs, pic_param->f_code[0][1], 4);
 326     bitstream_put_ui(bs, pic_param->f_code[1][0], 4);
 327     bitstream_put_ui(bs, pic_param->f_code[1][1], 4);
 328
 329     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.intra_dc_precision, 2);
 330     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.picture_structure, 2);
 331     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.top_field_first, 1);
 332     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.frame_pred_frame_dct, 1);
 333     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.concealment_motion_vectors, 1);
 334     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.q_scale_type, 1);
 335     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.intra_vlc_format, 1);
 336     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.alternate_scan, 1);
 337     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.repeat_first_field, 1);
 338     bitstream_put_ui(bs, chroma_420_type, 1);
 339     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.progressive_frame, 1);
 340     bitstream_put_ui(bs, pic_param->picture_coding_extension.bits.composite_display_flag, 1);
 341
 342     bitstream_byte_aligning(bs, 0);
 343
 344     if (pic_param->user_data_length) {
 345         bitstream_put_ui(bs, START_CODE_USER, 32);
 346
 347         for (i = 0; i < pic_param->user_data_length; i++) {
 348             bitstream_put_ui(bs, pic_param->user_data[i], 8);
 349         }
 350
 351         bitstream_byte_aligning(bs, 0);
 352     }
 353 }
 354
 355 static int
 356 build_packed_pic_buffer(const VAEncSequenceParameterBufferMPEG2 *seq_param,
 357                         const VAEncPictureParameterBufferMPEG2 *pic_param,
 358                         unsigned char **header_buffer)
 359 {
 360     bitstream bs;
 361
 362     bitstream_start(&bs);
 363     pps_rbsp(seq_param, pic_param, &bs);
 364     bitstream_end(&bs);
 365
 366     *header_buffer = (unsigned char *)bs.buffer;
 367     return bs.bit_offset;
 368 }
 369
 370 static int
 371 build_packed_seq_buffer(const VAEncSequenceParameterBufferMPEG2 *seq_param,
 372                         unsigned char **header_buffer)
 373 {
 374     bitstream bs;
 375
 376     bitstream_start(&bs);
 377     sps_rbsp(seq_param, &bs);
 378     bitstream_end(&bs);
 379
 380     *header_buffer = (unsigned char *)bs.buffer;
 381     return bs.bit_offset;
 382 }
 383
 384 /*
 385  * mpeg2enc
 386  */
 387 #define SID_INPUT_PICTURE_0                     0
 388 #define SID_INPUT_PICTURE_1                     1
 389 #define SID_REFERENCE_PICTURE_L0                2
 390 #define SID_REFERENCE_PICTURE_L1                3
 391 #define SID_RECON_PICTURE                       4
 392 #define SID_NUMBER                              SID_RECON_PICTURE + 1
 393
 394 static VASurfaceID surface_ids[SID_NUMBER];
 395
 396 /*
 397  * upload thread function
 398  */
 399 static void *
 400 upload_yuv_to_surface(void *data)
 401 {
 402     struct mpeg2enc_context *ctx = data;
 403     VAImage surface_image;
 404     VAStatus va_status;
 405     void *surface_p = NULL;
 406     unsigned char *y_src, *u_src, *v_src;
 407     unsigned char *y_dst, *u_dst, *v_dst;
 408     int y_size = ctx->width * ctx->height;
 409     int u_size = (ctx->width >> 1) * (ctx->height >> 1);
 410     int row, col;
 411     size_t n_items;
 412
 413     do {
 414         n_items = fread(ctx->frame_data_buffer, ctx->frame_size, 1, ctx->ifp);
 415     } while (n_items != 1);
 416
 417     va_status = vaDeriveImage(ctx->va_dpy, surface_ids[ctx->current_upload_surface], &surface_image);
 418     CHECK_VASTATUS(va_status,"vaDeriveImage");
 419
 420     vaMapBuffer(ctx->va_dpy, surface_image.buf, &surface_p);
 421     assert(VA_STATUS_SUCCESS == va_status);
 422
 423     y_src = ctx->frame_data_buffer;
 424     u_src = ctx->frame_data_buffer + y_size; /* UV offset for NV12 */
 425     v_src = ctx->frame_data_buffer + y_size + u_size;
 426
 427     y_dst = surface_p + surface_image.offsets[0];
 428     u_dst = surface_p + surface_image.offsets[1]; /* UV offset for NV12 */
 429     v_dst = surface_p + surface_image.offsets[2];
 430
 431     /* Y plane */
 432     for (row = 0; row < surface_image.height; row++) {
 433         memcpy(y_dst, y_src, surface_image.width);
 434         y_dst += surface_image.pitches[0];
 435         y_src += ctx->width;
 436     }
 437
 438     if (surface_image.format.fourcc == VA_FOURCC_NV12) { /* UV plane */
 439         for (row = 0; row < surface_image.height / 2; row++) {
 440             for (col = 0; col < surface_image.width / 2; col++) {
 441                 u_dst[col * 2] = u_src[col];
 442                 u_dst[col * 2 + 1] = v_src[col];
 443             }
 444
 445             u_dst += surface_image.pitches[1];
 446             u_src += (ctx->width / 2);
 447             v_src += (ctx->width / 2);
 448         }
 449     } else {
 450         for (row = 0; row < surface_image.height / 2; row++) {
 451             for (col = 0; col < surface_image.width / 2; col++) {
 452                 u_dst[col] = u_src[col];
 453                 v_dst[col] = v_src[col];
 454             }
 455
 456             u_dst += surface_image.pitches[1];
 457             v_dst += surface_image.pitches[2];
 458             u_src += (ctx->width / 2);
 459             v_src += (ctx->width / 2);
 460         }
 461     }
 462
 463     vaUnmapBuffer(ctx->va_dpy, surface_image.buf);
 464     vaDestroyImage(ctx->va_dpy, surface_image.image_id);
 465
 466     return NULL;
 467 }
 468
 469 static void
 470 mpeg2enc_exit(struct mpeg2enc_context *ctx, int exit_code)
 471 {
 472     if (ctx->frame_data_buffer) {
 473         free(ctx->frame_data_buffer);
 474         ctx->frame_data_buffer = NULL;
 475     }
 476
 477     if (ctx->ifp) {
 478         fclose(ctx->ifp);
 479         ctx->ifp = NULL;
 480     }
 481
 482     if (ctx->ofp) {
 483         fclose(ctx->ofp);
 484         ctx->ofp = NULL;
 485     }
 486
 487     exit(exit_code);
 488 }
 489
 490 static void
 491 usage(char *program)
 492 {
 493     fprintf(stderr, "Usage: %s --help\n", program);
 494     fprintf(stderr, "\t--help   print this message\n");
 495     fprintf(stderr, "Usage: %s <width> <height> <ifile> <ofile> [options]\n", program);
 496     fprintf(stderr, "\t<width>  specifies the frame width\n");
 497     fprintf(stderr, "\t<height> specifies the frame height\n");
 498     fprintf(stderr, "\t<ifile>  specifies the I420/IYUV YUV file\n");
 499     fprintf(stderr, "\t<ofile>  specifies the encoded MPEG-2 file\n");
 500     fprintf(stderr, "where options include:\n");
 501     fprintf(stderr, "\t--cqp <QP>       const qp mode with specified <QP>\n");
 502     fprintf(stderr, "\t--fps <FPS>      specify the frame rate\n");
 503 }
 504
 505 static void
 506 parse_args(struct mpeg2enc_context *ctx, int argc, char **argv)
 507 {
 508     int c, tmp, i = 0;
 509     int option_index = 0;
 510     long file_size;
 511     static struct option long_options[] = {
 512         {"help",        no_argument,            0,      'h'},
 513         {"cqp",         required_argument,      0,      'c'},
 514         {"fps",         required_argument,      0,      'f'},
 515         { NULL,         0,                      NULL,   0 }
 516     };
 517
 518     if ((argc == 2 && strcmp(argv[1], "--help") == 0) ||
 519         (argc < 5))
 520         goto print_usage;
 521
 522     ctx->width = atoi(argv[1]);
 523     ctx->height = atoi(argv[2]);
 524
 525     if (ctx->width <= 0 || ctx->height <= 0) {
 526         fprintf(stderr, "<width> and <height> must be greater than 0\n");
 527         goto err_exit;
 528     }
 529
 530     ctx->ifp = fopen(argv[3], "rb");
 531
 532     if (ctx->ifp == NULL) {
 533         fprintf(stderr, "Can't open the input file\n");
 534         goto err_exit;
 535     }
 536
 537     fseek(ctx->ifp, 0l, SEEK_END);
 538     file_size = ftell(ctx->ifp);
 539     ctx->frame_size = ctx->width * ctx->height * 3 / 2;
 540
 541     if ((file_size < ctx->frame_size) ||
 542         (file_size % ctx->frame_size)) {
 543         fprintf(stderr, "The input file size %ld isn't a multiple of the frame size %d\n", file_size, ctx->frame_size);
 544         goto err_exit;
 545     }
 546
 547     ctx->num_pictures = file_size / ctx->frame_size;
 548     fseek(ctx->ifp, 0l, SEEK_SET);
 549
 550     ctx->ofp = fopen(argv[4], "wb");
 551
 552     if (ctx->ofp == NULL) {
 553         fprintf(stderr, "Can't create the output file\n");
 554         goto err_exit;
 555     }
 556
 557     opterr = 0;
 558     ctx->fps = 30;
 559     ctx->qp = 28;
 560     ctx->rate_control_mode = VA_RC_CQP;
 561
 562     optind = 5;
 563
 564     while((c = getopt_long(argc, argv,
 565                            "",
 566                            long_options,
 567                            &option_index)) != -1) {
 568         switch(c) {
 569         case 'c':
 570             tmp = atoi(optarg);
 571
 572             /* only support q_scale_type = 0 */
 573             if (tmp > 62 || tmp < 2) {
 574                 fprintf(stderr, "Warning: QP must be in [2, 62]\n");
 575
 576                 if (tmp > 62)
 577                     tmp = 62;
 578
 579                 if (tmp < 2)
 580                     tmp = 2;
 581             }
 582
 583             ctx->qp = tmp & 0xFE;
 584             ctx->rate_control_mode = VA_RC_CQP;
 585
 586             break;
 587
 588         case 'f':
 589             tmp = atoi(optarg);
 590
 591             if (tmp <= 0)
 592                 fprintf(stderr, "Warning: FPS must be greater than 0\n");
 593             else
 594                 ctx->fps = tmp;
 595
 596             ctx->rate_control_mode = VA_RC_CBR;
 597
 598             break;
 599
 600         case '?':
 601             fprintf(stderr, "Error: unkown command options\n");
 602
 603         case 'h':
 604             goto print_usage;
 605         }
 606     }
 607
 608     return;
 609
 610 print_usage:
 611     usage(argv[0]);
 612 err_exit:
 613     mpeg2enc_exit(ctx, 1);
 614 }
 615
 616 /*
 617  * init
 618  */
 619 static void
 620 mpeg2enc_init_sequence_parameter(struct mpeg2enc_context *ctx,
 621                                 VAEncSequenceParameterBufferMPEG2 *seq_param)
 622 {
 623     seq_param->intra_period = ctx->intra_period;
 624     seq_param->ip_period = 0;   /* FIXME: ??? */
 625     seq_param->picture_width = ctx->width;
 626     seq_param->picture_height = ctx->height;
 627
 628     if (ctx->bit_rate > 0)
 629         seq_param->bits_per_second = 1024 * ctx->bit_rate; /* use kbps as input */
 630     else
 631         seq_param->bits_per_second = 0x3FFFF * 400;
 632
 633     seq_param->frame_rate = ctx->fps;
 634     seq_param->aspect_ratio_information = 1;
 635     seq_param->vbv_buffer_size = 3; /* B = 16 * 1024 * vbv_buffer_size */
 636
 637     seq_param->sequence_extension.bits.profile_and_level_indication = 4 << 4 | 0x8; /* FIXME: Main/Main ??? */
 638     seq_param->sequence_extension.bits.progressive_sequence = 1; /* progressive frame-pictures */
 639     seq_param->sequence_extension.bits.chroma_format = CHROMA_FORMAT_420; /* 4:2:0 */
 640     seq_param->sequence_extension.bits.low_delay = 0; /* FIXME */
 641     seq_param->sequence_extension.bits.frame_rate_extension_n = 0;
 642     seq_param->sequence_extension.bits.frame_rate_extension_d = 0;
 643
 644     seq_param->gop_header.bits.time_code = (1 << 12); /* bit12: marker_bit */
 645     seq_param->gop_header.bits.closed_gop = 0;
 646     seq_param->gop_header.bits.broken_link = 0;
 647 }
 648
 649 static void
 650 mpeg2enc_init_picture_parameter(struct mpeg2enc_context *ctx,
 651                                VAEncPictureParameterBufferMPEG2 *pic_param)
 652 {
 653     pic_param->forward_reference_picture = VA_INVALID_ID;
 654     pic_param->backward_reference_picture = VA_INVALID_ID;
 655     pic_param->reconstructed_picture = VA_INVALID_ID;
 656     pic_param->coded_buf = VA_INVALID_ID;
 657     pic_param->picture_type = VAEncPictureTypeIntra;
 658
 659     pic_param->temporal_reference = 0;
 660     pic_param->f_code[0][0] = 0xf;
 661     pic_param->f_code[0][1] = 0xf;
 662     pic_param->f_code[1][0] = 0xf;
 663     pic_param->f_code[1][1] = 0xf;
 664
 665     pic_param->picture_coding_extension.bits.intra_dc_precision = 0; /* 8bits */
 666     pic_param->picture_coding_extension.bits.picture_structure = 3; /* frame picture */
 667     pic_param->picture_coding_extension.bits.top_field_first = 0;
 668     pic_param->picture_coding_extension.bits.frame_pred_frame_dct = 1; /* FIXME */
 669     pic_param->picture_coding_extension.bits.concealment_motion_vectors = 0;
 670     pic_param->picture_coding_extension.bits.q_scale_type = 0;
 671     pic_param->picture_coding_extension.bits.intra_vlc_format = 0;
 672     pic_param->picture_coding_extension.bits.alternate_scan = 0;
 673     pic_param->picture_coding_extension.bits.repeat_first_field = 0;
 674     pic_param->picture_coding_extension.bits.progressive_frame = 1;
 675     pic_param->picture_coding_extension.bits.composite_display_flag = 0;
 676
 677     pic_param->user_data_length = 0;
 678 }
 679
 680 static void
 681 mpeg2enc_alloc_va_resources(struct mpeg2enc_context *ctx)
 682 {
 683     VAEntrypoint *entrypoint_list;
 684     VAConfigAttrib attrib_list[2];
 685     VAStatus va_status;
 686     int max_entrypoints, num_entrypoints, entrypoint;
 687     int major_ver, minor_ver;
 688
 689     ctx->va_dpy = va_open_display();
 690     va_status = vaInitialize(ctx->va_dpy,
 691                              &major_ver,
 692                              &minor_ver);
 693     CHECK_VASTATUS(va_status, "vaInitialize");
 694
 695     max_entrypoints = vaMaxNumEntrypoints(ctx->va_dpy);
 696     entrypoint_list = malloc(max_entrypoints * sizeof(VAEntrypoint));
 697     vaQueryConfigEntrypoints(ctx->va_dpy,
 698                              VAProfileMPEG2Simple,
 699                              entrypoint_list,
 700                              &num_entrypoints);
 701
 702     for (entrypoint = 0; entrypoint < num_entrypoints; entrypoint++) {
 703         if (entrypoint_list[entrypoint] == VAEntrypointEncSlice)
 704             break;
 705     }
 706
 707     free(entrypoint_list);
 708
 709     if (entrypoint == num_entrypoints) {
 710         /* not find Slice entry point */
 711         assert(0);
 712     }
 713
 714     /* find out the format for the render target, and rate control mode */
 715     attrib_list[0].type = VAConfigAttribRTFormat;
 716     attrib_list[1].type = VAConfigAttribRateControl;
 717     vaGetConfigAttributes(ctx->va_dpy,
 718                           VAProfileMPEG2Simple,
 719                           VAEntrypointEncSlice,
 720                           &attrib_list[0],
 721                           2);
 722
 723     if ((attrib_list[0].value & VA_RT_FORMAT_YUV420) == 0) {
 724         /* not find desired YUV420 RT format */
 725         assert(0);
 726     }
 727
 728     if ((attrib_list[1].value & ctx->rate_control_mode) == 0) {
 729         /* Can't find matched RC mode */
 730         fprintf(stderr, "RC mode %d isn't found, exit\n", ctx->rate_control_mode);
 731         assert(0);
 732     }
 733
 734     attrib_list[0].value = VA_RT_FORMAT_YUV420; /* set to desired RT format */
 735     attrib_list[1].value = ctx->rate_control_mode; /* set to desired RC mode */
 736
 737     va_status = vaCreateConfig(ctx->va_dpy,
 738                                VAProfileMPEG2Simple,
 739                                VAEntrypointEncSlice,
 740                                attrib_list,
 741                                2,
 742                                &ctx->config_id);
 743     CHECK_VASTATUS(va_status, "vaCreateConfig");
 744
 745     /* Create a context for this decode pipe */
 746     va_status = vaCreateContext(ctx->va_dpy,
 747                                 ctx->config_id,
 748                                 ctx->width,
 749                                 ctx->height,
 750                                 VA_PROGRESSIVE,
 751                                 0,
 752                                 0,
 753                                 &ctx->context_id);
 754     CHECK_VASTATUS(va_status, "vaCreateContext");
 755
 756     va_status = vaCreateSurfaces(ctx->va_dpy,
 757                                  VA_RT_FORMAT_YUV420,
 758                                  ctx->width,
 759                                  ctx->height,
 760                                  surface_ids,
 761                                  SID_NUMBER,
 762                                  NULL,
 763                                  0);
 764     CHECK_VASTATUS(va_status, "vaCreateSurfaces");
 765 }
 766
 767 static void
 768 mpeg2enc_init(struct mpeg2enc_context *ctx)
 769 {
 770     int i;
 771
 772     ctx->frame_data_buffer = (unsigned char *)malloc(ctx->frame_size);
 773     ctx->seq_param_buf_id = VA_INVALID_ID;
 774     ctx->pic_param_buf_id = VA_INVALID_ID;
 775     ctx->packed_seq_header_param_buf_id = VA_INVALID_ID;
 776     ctx->packed_seq_buf_id = VA_INVALID_ID;
 777     ctx->packed_pic_header_param_buf_id = VA_INVALID_ID;
 778     ctx->packed_pic_buf_id = VA_INVALID_ID;
 779     ctx->codedbuf_buf_id = VA_INVALID_ID;
 780     ctx->codedbuf_i_size = ctx->frame_size;
 781     ctx->codedbuf_pb_size = 0;
 782     ctx->intra_period = INTRA_PERIOD;
 783     ctx->bit_rate = -1;
 784
 785     for (i = 0; i < MAX_SLICES; i++) {
 786         ctx->slice_param_buf_id[i] = VA_INVALID_ID;
 787     }
 788
 789     mpeg2enc_init_sequence_parameter(ctx, &ctx->seq_param);
 790     mpeg2enc_init_picture_parameter(ctx, &ctx->pic_param);
 791     mpeg2enc_alloc_va_resources(ctx);
 792
 793     /* thread */
 794     ctx->current_input_surface = SID_INPUT_PICTURE_0;
 795     ctx->current_upload_surface = SID_INPUT_PICTURE_1;
 796     ctx->upload_thread_value = pthread_create(&ctx->upload_thread_id,
 797                                               NULL,
 798                                               upload_yuv_to_surface,
 799                                               ctx);
 800 }
 801
 802 /*
 803  * run
 804  */
 805 static void
 806 mpeg2enc_update_picture_parameter(struct mpeg2enc_context *ctx,
 807                                  VAEncPictureType picture_type,
 808                                  int coded_order,
 809                                  int display_order)
 810 {
 811     VAEncPictureParameterBufferMPEG2 *pic_param;
 812     VAStatus va_status;
 813
 814     // Picture level
 815     pic_param = &ctx->pic_param;
 816     pic_param->picture_type = picture_type;
 817     pic_param->temporal_reference = display_order;
 818     pic_param->reconstructed_picture = surface_ids[SID_RECON_PICTURE];
 819     pic_param->forward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L0];
 820     pic_param->backward_reference_picture = surface_ids[SID_REFERENCE_PICTURE_L1];
 821     pic_param->coded_buf = ctx->codedbuf_buf_id;
 822
 823     va_status = vaCreateBuffer(ctx->va_dpy,
 824                                ctx->context_id,
 825                                VAEncPictureParameterBufferType,
 826                                sizeof(*pic_param),
 827                                1,
 828                                pic_param,
 829                                &ctx->pic_param_buf_id);
 830     CHECK_VASTATUS(va_status, "vaCreateBuffer");
 831 }
 832
 833 static void
 834 mpeg2enc_update_slice_parameter(struct mpeg2enc_context *ctx, VAEncPictureType picture_type)
 835 {
 836     VAEncSequenceParameterBufferMPEG2 *seq_param;
 837     VAEncPictureParameterBufferMPEG2 *pic_param;
 838     VAEncSliceParameterBufferMPEG2 *slice_param;
 839     VAStatus va_status;
 840     int i, width_in_mbs, height_in_mbs;
 841
 842     pic_param = &ctx->pic_param;
 843     assert(pic_param->picture_coding_extension.bits.q_scale_type == 0);
 844
 845     seq_param = &ctx->seq_param;
 846     width_in_mbs = (seq_param->picture_width + 15) / 16;
 847     height_in_mbs = (seq_param->picture_height + 15) / 16;
 848     ctx->num_slice_groups = 1;
 849
 850     for (i = 0; i < height_in_mbs; i++) {
 851         slice_param = &ctx->slice_param[i];
 852         slice_param->macroblock_address = i * width_in_mbs;
 853         slice_param->num_macroblocks = width_in_mbs;
 854         slice_param->is_intra_slice = (picture_type == VAEncPictureTypeIntra);
 855         slice_param->quantiser_scale_code = ctx->qp / 2;
 856     }
 857
 858     va_status = vaCreateBuffer(ctx->va_dpy,
 859                                ctx->context_id,
 860                                VAEncSliceParameterBufferType,
 861                                sizeof(*slice_param),
 862                                height_in_mbs,
 863                                ctx->slice_param,
 864                                ctx->slice_param_buf_id);
 865     CHECK_VASTATUS(va_status, "vaCreateBuffer");;
 866 }
 867
 868 static int
 869 begin_picture(struct mpeg2enc_context *ctx,
 870               int coded_order,
 871               int display_order,
 872               VAEncPictureType picture_type)
 873 {
 874     VAStatus va_status;
 875     int tmp;
 876     VAEncPackedHeaderParameterBuffer packed_header_param_buffer;
 877     unsigned int length_in_bits;
 878     unsigned char *packed_seq_buffer = NULL, *packed_pic_buffer = NULL;
 879
 880     if (ctx->upload_thread_value != 0) {
 881         fprintf(stderr, "FATAL error!!!\n");
 882         exit(1);
 883     }
 884
 885     pthread_join(ctx->upload_thread_id, NULL);
 886
 887     ctx->upload_thread_value = -1;
 888     tmp = ctx->current_input_surface;
 889     ctx->current_input_surface = ctx->current_upload_surface;
 890     ctx->current_upload_surface = tmp;
 891
 892     if (coded_order == 0) {
 893         assert(picture_type == VAEncPictureTypeIntra);
 894         length_in_bits = build_packed_seq_buffer(&ctx->seq_param, &packed_seq_buffer);
 895         packed_header_param_buffer.type = VAEncPackedHeaderMPEG2_SPS;
 896         packed_header_param_buffer.has_emulation_bytes = 0;
 897         packed_header_param_buffer.bit_length = length_in_bits;
 898         va_status = vaCreateBuffer(ctx->va_dpy,
 899                                    ctx->context_id,
 900                                    VAEncPackedHeaderParameterBufferType,
 901                                    sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
 902                                    &ctx->packed_seq_header_param_buf_id);
 903         CHECK_VASTATUS(va_status,"vaCreateBuffer");
 904
 905         va_status = vaCreateBuffer(ctx->va_dpy,
 906                                    ctx->context_id,
 907                                    VAEncPackedHeaderDataBufferType,
 908                                    (length_in_bits + 7) / 8, 1, packed_seq_buffer,
 909                                    &ctx->packed_seq_buf_id);
 910         CHECK_VASTATUS(va_status,"vaCreateBuffer");
 911
 912         free(packed_seq_buffer);
 913     }
 914
 915     length_in_bits = build_packed_pic_buffer(&ctx->seq_param, &ctx->pic_param, &packed_pic_buffer);
 916     packed_header_param_buffer.type = VAEncPackedHeaderMPEG2_PPS;
 917     packed_header_param_buffer.has_emulation_bytes = 0;
 918     packed_header_param_buffer.bit_length = length_in_bits;
 919
 920     va_status = vaCreateBuffer(ctx->va_dpy,
 921                                ctx->context_id,
 922                                VAEncPackedHeaderParameterBufferType,
 923                                sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer,
 924                                &ctx->packed_pic_header_param_buf_id);
 925     CHECK_VASTATUS(va_status,"vaCreateBuffer");
 926
 927     va_status = vaCreateBuffer(ctx->va_dpy,
 928                                ctx->context_id,
 929                                VAEncPackedHeaderDataBufferType,
 930                                (length_in_bits + 7) / 8, 1, packed_pic_buffer,
 931                                &ctx->packed_pic_buf_id);
 932     CHECK_VASTATUS(va_status,"vaCreateBuffer");
 933
 934     free(packed_pic_buffer);
 935
 936     /* sequence parameter set */
 937     VAEncSequenceParameterBufferMPEG2 *seq_param = &ctx->seq_param;
 938     va_status = vaCreateBuffer(ctx->va_dpy,
 939                                ctx->context_id,
 940                                VAEncSequenceParameterBufferType,
 941                                sizeof(*seq_param),
 942                                1,
 943                                seq_param,
 944                                &ctx->seq_param_buf_id);
 945     CHECK_VASTATUS(va_status,"vaCreateBuffer");;
 946
 947     /* slice parameter */
 948     mpeg2enc_update_slice_parameter(ctx, picture_type);
 949
 950     return 0;
 951 }
 952
 953 static int
 954 mpeg2enc_render_picture(struct mpeg2enc_context *ctx)
 955 {
 956     VAStatus va_status;
 957     VABufferID va_buffers[16];
 958     unsigned int num_va_buffers = 0;
 959
 960     va_buffers[num_va_buffers++] = ctx->seq_param_buf_id;
 961     va_buffers[num_va_buffers++] = ctx->pic_param_buf_id;
 962
 963     if (ctx->packed_seq_header_param_buf_id != VA_INVALID_ID)
 964         va_buffers[num_va_buffers++] = ctx->packed_seq_header_param_buf_id;
 965
 966     if (ctx->packed_seq_buf_id != VA_INVALID_ID)
 967         va_buffers[num_va_buffers++] = ctx->packed_seq_buf_id;
 968
 969     if (ctx->packed_pic_header_param_buf_id != VA_INVALID_ID)
 970         va_buffers[num_va_buffers++] = ctx->packed_pic_header_param_buf_id;
 971
 972     if (ctx->packed_pic_buf_id != VA_INVALID_ID)
 973         va_buffers[num_va_buffers++] = ctx->packed_pic_buf_id;
 974
 975     va_status = vaBeginPicture(ctx->va_dpy,
 976                                ctx->context_id,
 977                                surface_ids[ctx->current_input_surface]);
 978     CHECK_VASTATUS(va_status,"vaBeginPicture");
 979
 980     va_status = vaRenderPicture(ctx->va_dpy,
 981                                 ctx->context_id,
 982                                 va_buffers,
 983                                 num_va_buffers);
 984     CHECK_VASTATUS(va_status,"vaRenderPicture");
 985
 986     va_status = vaRenderPicture(ctx->va_dpy,
 987                                 ctx->context_id,
 988                                 &ctx->slice_param_buf_id[0],
 989                                 ctx->num_slice_groups);
 990     CHECK_VASTATUS(va_status,"vaRenderPicture");
 991
 992     va_status = vaEndPicture(ctx->va_dpy, ctx->context_id);
 993     CHECK_VASTATUS(va_status,"vaEndPicture");
 994
 995     return 0;
 996 }
 997
 998 static int
 999 mpeg2enc_destroy_buffers(struct mpeg2enc_context *ctx, VABufferID *va_buffers, unsigned int num_va_buffers)
1000 {
1001     VAStatus va_status;
1002     unsigned int i;
1003
1004     for (i = 0; i < num_va_buffers; i++) {
1005         if (va_buffers[i] != VA_INVALID_ID) {
1006             va_status = vaDestroyBuffer(ctx->va_dpy, va_buffers[i]);
1007             CHECK_VASTATUS(va_status,"vaDestroyBuffer");
1008             va_buffers[i] = VA_INVALID_ID;
1009         }
1010     }
1011
1012     return 0;
1013 }
1014
1015 static void
1016 end_picture(struct mpeg2enc_context *ctx, VAEncPictureType picture_type, int next_is_bpic)
1017 {
1018     VABufferID tempID;
1019
1020     /* Prepare for next picture */
1021     tempID = surface_ids[SID_RECON_PICTURE];
1022
1023     if (picture_type != VAEncPictureTypeBidirectional) {
1024         if (next_is_bpic) {
1025             surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L1];
1026             surface_ids[SID_REFERENCE_PICTURE_L1] = tempID;
1027         } else {
1028             surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L0];
1029             surface_ids[SID_REFERENCE_PICTURE_L0] = tempID;
1030         }
1031     } else {
1032         if (!next_is_bpic) {
1033             surface_ids[SID_RECON_PICTURE] = surface_ids[SID_REFERENCE_PICTURE_L0];
1034             surface_ids[SID_REFERENCE_PICTURE_L0] = surface_ids[SID_REFERENCE_PICTURE_L1];
1035             surface_ids[SID_REFERENCE_PICTURE_L1] = tempID;
1036         }
1037     }
1038
1039     mpeg2enc_destroy_buffers(ctx, &ctx->seq_param_buf_id, 1);
1040     mpeg2enc_destroy_buffers(ctx, &ctx->pic_param_buf_id, 1);
1041     mpeg2enc_destroy_buffers(ctx, &ctx->packed_seq_header_param_buf_id, 1);
1042     mpeg2enc_destroy_buffers(ctx, &ctx->packed_seq_buf_id, 1);
1043     mpeg2enc_destroy_buffers(ctx, &ctx->packed_pic_header_param_buf_id, 1);
1044     mpeg2enc_destroy_buffers(ctx, &ctx->packed_pic_buf_id, 1);
1045     mpeg2enc_destroy_buffers(ctx, &ctx->slice_param_buf_id[0], ctx->num_slice_groups);
1046     mpeg2enc_destroy_buffers(ctx, &ctx->codedbuf_buf_id, 1);
1047     memset(ctx->slice_param, 0, sizeof(ctx->slice_param));
1048     ctx->num_slice_groups = 0;
1049 }
1050
1051 static int
1052 store_coded_buffer(struct mpeg2enc_context *ctx, VAEncPictureType picture_type)
1053 {
1054     VACodedBufferSegment *coded_buffer_segment;
1055     unsigned char *coded_mem;
1056     int slice_data_length;
1057     VAStatus va_status;
1058     VASurfaceStatus surface_status;
1059     size_t w_items;
1060
1061     va_status = vaSyncSurface(ctx->va_dpy, surface_ids[ctx->current_input_surface]);
1062     CHECK_VASTATUS(va_status,"vaSyncSurface");
1063
1064     surface_status = 0;
1065     va_status = vaQuerySurfaceStatus(ctx->va_dpy, surface_ids[ctx->current_input_surface], &surface_status);
1066     CHECK_VASTATUS(va_status,"vaQuerySurfaceStatus");
1067
1068     va_status = vaMapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id, (void **)(&coded_buffer_segment));
1069     CHECK_VASTATUS(va_status,"vaMapBuffer");
1070     coded_mem = coded_buffer_segment->buf;
1071
1072     if (coded_buffer_segment->status & VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK) {
1073         if (picture_type == VAEncPictureTypeIntra)
1074             ctx->codedbuf_i_size *= 2;
1075         else
1076             ctx->codedbuf_pb_size *= 2;
1077
1078         vaUnmapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id);
1079         return -1;
1080     }
1081
1082     slice_data_length = coded_buffer_segment->size;
1083
1084     do {
1085         w_items = fwrite(coded_mem, slice_data_length, 1, ctx->ofp);
1086     } while (w_items != 1);
1087
1088     if (picture_type == VAEncPictureTypeIntra) {
1089         if (ctx->codedbuf_i_size > slice_data_length * 3 / 2) {
1090             ctx->codedbuf_i_size = slice_data_length * 3 / 2;
1091         }
1092
1093         if (ctx->codedbuf_pb_size < slice_data_length) {
1094             ctx->codedbuf_pb_size = slice_data_length;
1095         }
1096     } else {
1097         if (ctx->codedbuf_pb_size > slice_data_length * 3 / 2) {
1098             ctx->codedbuf_pb_size = slice_data_length * 3 / 2;
1099         }
1100     }
1101
1102     vaUnmapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id);
1103
1104     return 0;
1105 }
1106
1107 static void
1108 encode_picture(struct mpeg2enc_context *ctx,
1109                int coded_order,
1110                int display_order,
1111                VAEncPictureType picture_type,
1112                int next_is_bpic,
1113                int next_display_order)
1114 {
1115     VAStatus va_status;
1116     int ret = 0, codedbuf_size;
1117
1118     begin_picture(ctx, coded_order, display_order, picture_type);
1119
1120     if (1) {
1121         /* upload YUV data to VA surface for next frame */
1122         if (next_display_order >= ctx->num_pictures)
1123             next_display_order = ctx->num_pictures - 1;
1124
1125         fseek(ctx->ifp, ctx->frame_size * next_display_order, SEEK_SET);
1126         ctx->upload_thread_value = pthread_create(&ctx->upload_thread_id,
1127                                                   NULL,
1128                                                   upload_yuv_to_surface,
1129                                                   ctx);
1130     }
1131
1132     do {
1133         mpeg2enc_destroy_buffers(ctx, &ctx->codedbuf_buf_id, 1);
1134         mpeg2enc_destroy_buffers(ctx, &ctx->pic_param_buf_id, 1);
1135
1136
1137         if (VAEncPictureTypeIntra == picture_type) {
1138             codedbuf_size = ctx->codedbuf_i_size;
1139         } else {
1140             codedbuf_size = ctx->codedbuf_pb_size;
1141         }
1142
1143         /* coded buffer */
1144         va_status = vaCreateBuffer(ctx->va_dpy,
1145                                    ctx->context_id,
1146                                    VAEncCodedBufferType,
1147                                    codedbuf_size, 1, NULL,
1148                                    &ctx->codedbuf_buf_id);
1149         CHECK_VASTATUS(va_status,"vaCreateBuffer");
1150
1151         /* picture parameter set */
1152         mpeg2enc_update_picture_parameter(ctx, picture_type, coded_order, display_order);
1153
1154         mpeg2enc_render_picture(ctx);
1155
1156         ret = store_coded_buffer(ctx, picture_type);
1157     } while (ret);
1158
1159     end_picture(ctx, picture_type, next_is_bpic);
1160 }
1161
1162 static void
1163 encode_pb_pictures(struct mpeg2enc_context *ctx,
1164                    int coded_order,
1165                    int f,
1166                    int nbframes,
1167                    int next_f)
1168 {
1169     int i;
1170
1171     encode_picture(ctx,
1172                    coded_order,
1173                    f + nbframes,
1174                    VAEncPictureTypePredictive,
1175                    1,
1176                    f);
1177
1178     for( i = 0; i < nbframes - 1; i++) {
1179         encode_picture(ctx,
1180                        coded_order + 1,
1181                        f + i,
1182                        VAEncPictureTypeBidirectional,
1183                        1,
1184                        f + i + 1);
1185     }
1186
1187     encode_picture(ctx,
1188                    coded_order + 1,
1189                    f + nbframes - 1,
1190                    VAEncPictureTypeBidirectional,
1191                    0,
1192                    next_f);
1193 }
1194
1195 static void
1196 mpeg2enc_run(struct mpeg2enc_context *ctx)
1197 {
1198     int display_order = 0, coded_order = 0;
1199     int i_frame_only = 1, i_p_frame_only = 1;
1200
1201     for (display_order = 0; display_order < ctx->num_pictures;) {
1202         if (i_frame_only) {
1203             encode_picture(ctx,
1204                            coded_order,
1205                            display_order,
1206                            VAEncPictureTypeIntra,
1207                            0,
1208                            display_order + 1);
1209             display_order++;
1210             coded_order++;
1211         } else if (i_p_frame_only) {
1212             if ((display_order % ctx->intra_period) == 0) {
1213                 encode_picture(ctx,
1214                                coded_order,
1215                                display_order,
1216                                VAEncPictureTypeIntra,
1217                                0,
1218                                display_order + 1);
1219                 display_order++;
1220                 coded_order++;
1221             } else {
1222                 encode_picture(ctx,
1223                                coded_order,
1224                                display_order,
1225                                VAEncPictureTypePredictive,
1226                                0,
1227                                display_order + 1);
1228                 display_order++;
1229                 coded_order++;
1230             }
1231         } else { // follow the i,p,b pattern
1232             static int fcurrent = 0;
1233             int fnext;
1234
1235             fcurrent = fcurrent % (sizeof(picture_type_patter)/sizeof(int[2]));
1236             fnext = (fcurrent+1) % (sizeof(picture_type_patter)/sizeof(int[2]));
1237
1238             if ( picture_type_patter[fcurrent][0] == VAEncPictureTypeIntra ) {
1239                 encode_picture(ctx,
1240                                coded_order,
1241                                display_order,
1242                                VAEncPictureTypeIntra,
1243                                0,
1244                                display_order + picture_type_patter[fnext][1]);
1245                 display_order++;
1246                 coded_order++;
1247             } else {
1248                 encode_pb_pictures(ctx,
1249                                    coded_order,
1250                                    display_order,
1251                                    picture_type_patter[fcurrent][1] - 1,
1252                                    display_order + picture_type_patter[fcurrent][1] + picture_type_patter[fnext][1] - 1);
1253                 display_order += picture_type_patter[fcurrent][1];
1254                 coded_order++;
1255             }
1256
1257             fcurrent++;
1258         }
1259
1260         fprintf(stderr, "\r %d/%d ...", display_order + 1, ctx->num_pictures);
1261         fflush(stdout);
1262     }
1263 }
1264
1265 /*
1266  * end
1267  */
1268 static void
1269 mpeg2enc_release_va_resources(struct mpeg2enc_context *ctx)
1270 {
1271     vaDestroySurfaces(ctx->va_dpy, surface_ids, SID_NUMBER);
1272     vaDestroyContext(ctx->va_dpy, ctx->context_id);
1273     vaDestroyConfig(ctx->va_dpy, ctx->config_id);
1274     vaTerminate(ctx->va_dpy);
1275     va_close_display(ctx->va_dpy);
1276 }
1277
1278 static void
1279 mpeg2enc_end(struct mpeg2enc_context *ctx)
1280 {
1281     pthread_join(ctx->upload_thread_id, NULL);
1282     mpeg2enc_release_va_resources(ctx);
1283 }
1284
1285 int
1286 main(int argc, char *argv[])
1287 {
1288     struct mpeg2enc_context ctx;
1289     struct timeval tpstart, tpend;
1290     float timeuse;
1291
1292     gettimeofday(&tpstart, NULL);
1293
1294     memset(&ctx, 0, sizeof(ctx));
1295     parse_args(&ctx, argc, argv);
1296     mpeg2enc_init(&ctx);
1297     mpeg2enc_run(&ctx);
1298     mpeg2enc_end(&ctx);
1299
1300     gettimeofday(&tpend, NULL);
1301     timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) + tpend.tv_usec - tpstart.tv_usec;
1302     timeuse /= 1000000;
1303     fprintf(stderr, "\ndone!\n");
1304     fprintf(stderr, "encode %d frames in %f secondes, FPS is %.1f\n", ctx.num_pictures, timeuse, ctx.num_pictures / timeuse);
1305
1306     mpeg2enc_exit(&ctx, 0);
1307
1308     return 0;
1309 }