cinelerra-5.0/quicktime/mpeg4.c

   1 /* General codec for all MPEG-4 derived encoding. */
   2 /* Uses ffmpeg and encore50. */
   3 /* Encore50 still seemed to provide better results than ffmpeg for encoding */
   4 /* so it does all the generic MPEG-4 encoding. */
   5
   6
   7
   8
   9
  10 #include "colormodels.h"
  11 #include "funcprotos.h"
  12 #include "qtffmpeg.h"
  13 #include "quicktime.h"
  14 #include "workarounds.h"
  15 #include ENCORE_INCLUDE
  16 //#include DECORE_INCLUDE
  17
  18 #include <stdint.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #define FRAME_RATE_BASE 10000
  23 #define FIELDS 2
  24
  25
  26 typedef struct
  27 {
  28
  29 // Decoder side
  30         quicktime_ffmpeg_t *decoder;
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40 // Encoding side
  41         int encode_initialized[FIELDS];
  42 // Information for picking the right library routines.
  43 // ID out of avcodec.h for the codec used.
  44 // Invalid if encore50 is used.
  45         int ffmpeg_id;
  46 // True if encore50 is being used.
  47         int use_encore;
  48
  49 // FFMpeg internals
  50     AVCodec *encoder[FIELDS];
  51         AVCodecContext *encoder_context[FIELDS];
  52     AVFrame picture[FIELDS];
  53
  54
  55 // Encore internals
  56         int encode_handle[FIELDS];
  57         ENC_PARAM enc_param[FIELDS];
  58 // Must count pframes in VBR
  59         int p_count[FIELDS];
  60
  61
  62 // Encoding parameters
  63         int bitrate;
  64 // For heroine 60 encoding, we want different streams for each field.
  65         int total_fields;
  66         long rc_period;          // the intended rate control averaging period
  67         long rc_reaction_period; // the reation period for rate control
  68         long rc_reaction_ratio;  // the ratio for down/up rate control
  69         long max_key_interval;   // the maximum interval between key frames
  70         int bitrate_tolerance;
  71         int interlaced;
  72         int gop_size;
  73         int max_quantizer;       // the upper limit of the quantizer
  74         int min_quantizer;       // the lower limit of the quantizer
  75         int quantizer;           // For vbr
  76         int quality;             // the forward search range for motion estimation
  77         int fix_bitrate;
  78         int use_deblocking;
  79
  80
  81 // Temporary storage for color conversions
  82         char *temp_frame;
  83 // Storage of compressed data
  84         unsigned char *work_buffer;
  85 // Allocation of work_buffer
  86         int buffer_size;
  87 } quicktime_mpeg4_codec_t;
  88
  89
  90
  91 // Decore needs the user to specify handles
  92 static int encode_handle = 0;
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102 // Direct copy routines
 103
 104
 105 // Determine of the compressed frame is a keyframe for direct copy
 106 int quicktime_mpeg4_is_key(unsigned char *data, long size, char *codec_id)
 107 {
 108         int result = 0;
 109         int i;
 110
 111         if(quicktime_match_32(codec_id, QUICKTIME_DIVX) ||
 112                 quicktime_match_32(codec_id, QUICKTIME_MP4V) ||
 113                 quicktime_match_32(codec_id, QUICKTIME_HV60))
 114         {
 115                 for(i = 0; i < size - 5; i++)
 116                 {
 117                         if( data[i]     == 0x00 &&
 118                                 data[i + 1] == 0x00 &&
 119                                 data[i + 2] == 0x01 &&
 120                                 data[i + 3] == 0xb6)
 121                         {
 122                                 if((data[i + 4] & 0xc0) == 0x0)
 123                                         return 1;
 124                                 else
 125                                         return 0;
 126                         }
 127                 }
 128         }
 129         return result;
 130 }
 131
 132
 133 // Test for VOL header in frame
 134 int quicktime_mpeg4_has_vol(unsigned char *data)
 135 {
 136         if( data[0] == 0x00 &&
 137                 data[1] == 0x00 &&
 138                 data[2] == 0x01 &&
 139                 data[3] == 0x00 &&
 140                 data[4] == 0x00 &&
 141                 data[5] == 0x00 &&
 142                 data[6] == 0x01 &&
 143                 data[7] == 0x20)
 144                 return 1;
 145         else
 146                 return 0;
 147 }
 148
 149
 150
 151
 152 static void putbits(unsigned char **data,
 153         int *bit_pos,
 154         uint64_t *bit_store,
 155         int *total,
 156         int count,
 157         uint64_t value)
 158 {
 159         value &= 0xffffffffffffffffLL >> (64 - count);
 160
 161         while(64 - *bit_pos < count)
 162         {
 163                 *(*data)++ = (*bit_store) >> 56;
 164                 (*bit_store) <<= 8;
 165                 (*bit_pos) -= 8;
 166         }
 167
 168         (*bit_store) |= value << (64 - count - *bit_pos);
 169         (*bit_pos) += count;
 170         (*total) += count;
 171 }
 172
 173
 174 static void flushbits(unsigned char **data,
 175         int *bit_pos,
 176         uint64_t *bit_store)
 177 {
 178 //printf("flushbits %llx\n", (*bit_store));
 179         while((*bit_pos) > 0)
 180         {
 181                 *(*data)++ = (*bit_store) >> 56;
 182                 (*bit_store) <<= 8;
 183                 (*bit_pos) -= 8;
 184         }
 185 }
 186
 187
 188
 189
 190 #define VO_START_CODE           0x8
 191 #define VO_START_CODE_LENGTH    27
 192 #define VOL_START_CODE 0x12             /* 25-MAR-97 JDL : according to WD2 */
 193 #define VOL_START_CODE_LENGTH 28
 194
 195
 196
 197 int quicktime_mpeg4_write_vol(unsigned char *data_start,
 198         int vol_width,
 199         int vol_height,
 200         int time_increment_resolution,
 201         double frame_rate)
 202 {
 203         int written = 0;
 204         int bits, fixed_vop_time_increment;
 205         unsigned char *data = data_start;
 206         int bit_pos;
 207         uint64_t bit_store;
 208
 209         bit_store = 0;
 210         bit_pos = 0;
 211         vol_width = quicktime_quantize16(vol_width);
 212         vol_height = quicktime_quantize16(vol_height);
 213
 214
 215         putbits(&data,
 216                 &bit_pos,
 217                 &bit_store,
 218                 &written,
 219                 VO_START_CODE_LENGTH, VO_START_CODE);
 220         putbits(&data,
 221                 &bit_pos,
 222                 &bit_store,
 223                 &written,
 224                 5, 0);                          /* vo_id = 0                                                            */
 225
 226         putbits(&data,
 227                 &bit_pos,
 228                 &bit_store,
 229                 &written,
 230                 VOL_START_CODE_LENGTH, VOL_START_CODE);
 231
 232
 233
 234         putbits(&data,
 235                 &bit_pos,
 236                 &bit_store,
 237                 &written,
 238                 4, 0);                          /* vol_id = 0                                                           */
 239
 240         putbits(&data,
 241                 &bit_pos,
 242                 &bit_store,
 243                 &written,
 244                 1, 0);                          /* random_accessible_vol = 0                            */
 245         putbits(&data,
 246                 &bit_pos,
 247                 &bit_store,
 248                 &written,
 249                 8, 1);                          /* video_object_type_indication = 1 video       */
 250         putbits(&data,
 251                 &bit_pos,
 252                 &bit_store,
 253                 &written,
 254                 1, 1);                          /* is_object_layer_identifier = 1                       */
 255         putbits(&data,
 256                 &bit_pos,
 257                 &bit_store,
 258                 &written,
 259                 4, 2);                          /* visual_object_layer_ver_id = 2                       */
 260         putbits(&data,
 261                 &bit_pos,
 262                 &bit_store,
 263                 &written,
 264                 3, 1);                          /* visual_object_layer_priority = 1                     */
 265         putbits(&data,
 266                 &bit_pos,
 267                 &bit_store,
 268                 &written,
 269                 4, 1);                          /* aspect_ratio_info = 1                                        */
 270
 271
 272
 273
 274
 275
 276
 277         putbits(&data,
 278                 &bit_pos,
 279                 &bit_store,
 280                 &written,
 281                 1, 0);                          /* vol_control_parameter = 0                            */
 282         putbits(&data,
 283                 &bit_pos,
 284                 &bit_store,
 285                 &written,
 286                 2, 0);                          /* vol_shape = 0 rectangular                            */
 287         putbits(&data,
 288                 &bit_pos,
 289                 &bit_store,
 290                 &written,
 291                 1, 1);                          /* marker                                                                       */
 292
 293
 294
 295
 296
 297
 298
 299         putbits(&data,
 300                 &bit_pos,
 301                 &bit_store,
 302                 &written,
 303                 16, time_increment_resolution);
 304         putbits(&data,
 305                 &bit_pos,
 306                 &bit_store,
 307                 &written,
 308                 1, 1);                          /* marker                                                                       */
 309         putbits(&data,
 310                 &bit_pos,
 311                 &bit_store,
 312                 &written,
 313                 1, 1);                          /* fixed_vop_rate = 1                                           */
 314
 315
 316         bits = 1;
 317         while((1 << bits) < time_increment_resolution) bits++;
 318
 319 // Log calculation fails for some reason
 320 //      bits = (int)ceil(log((double)time_increment_resolution) / log(2.0));
 321 //    if (bits < 1) bits=1;
 322
 323         fixed_vop_time_increment =
 324                 (int)(time_increment_resolution / frame_rate + 0.1);
 325
 326         putbits(&data,
 327                 &bit_pos,
 328                 &bit_store,
 329                 &written,
 330                 bits, fixed_vop_time_increment);
 331
 332         putbits(&data,
 333                 &bit_pos,
 334                 &bit_store,
 335                 &written,
 336                 1, 1);                          /* marker                                                                       */
 337
 338         putbits(&data,
 339                 &bit_pos,
 340                 &bit_store,
 341                 &written,
 342                 13, vol_width);
 343         putbits(&data,
 344                 &bit_pos,
 345                 &bit_store,
 346                 &written,
 347                 1, 1);                          /* marker                                                                       */
 348         putbits(&data,
 349                 &bit_pos,
 350                 &bit_store,
 351                 &written,
 352                 13, vol_height);
 353         putbits(&data,
 354                 &bit_pos,
 355                 &bit_store,
 356                 &written,
 357                 1, 1);                          /* marker                                                                       */
 358
 359         putbits(&data,
 360                 &bit_pos,
 361                 &bit_store,
 362                 &written,
 363                 1, 0);                          /* interlaced = 0                                                       */
 364         putbits(&data,
 365                 &bit_pos,
 366                 &bit_store,
 367                 &written,
 368                 1, 1);                          /* OBMC_disabled = 1                                            */
 369         putbits(&data,
 370                 &bit_pos,
 371                 &bit_store,
 372                 &written,
 373                 2, 0);                          /* vol_sprite_usage = 0                                         */
 374         putbits(&data,
 375                 &bit_pos,
 376                 &bit_store,
 377                 &written,
 378                 1, 0);                          /* not_8_bit = 0                                                        */
 379
 380         putbits(&data,
 381                 &bit_pos,
 382                 &bit_store,
 383                 &written,
 384                 1, 0);                          /* vol_quant_type = 0                                           */
 385         putbits(&data,
 386                 &bit_pos,
 387                 &bit_store,
 388                 &written,
 389                 1, 0);                          /* vol_quarter_pixel = 0                                        */
 390         putbits(&data,
 391                 &bit_pos,
 392                 &bit_store,
 393                 &written,
 394                 1, 1);                          /* complexity_estimation_disabled = 1           */
 395         putbits(&data,
 396                 &bit_pos,
 397                 &bit_store,
 398                 &written,
 399                 1, 1);                          /* resync_marker_disabled = 1                           */
 400         putbits(&data,
 401                 &bit_pos,
 402                 &bit_store,
 403                 &written,
 404                 1, 0);                          /* data_partitioning_enabled = 0                        */
 405         putbits(&data,
 406                 &bit_pos,
 407                 &bit_store,
 408                 &written,
 409                 1, 0);                          /* scalability = 0                                                      */
 410
 411         flushbits(&data,
 412                 &bit_pos,
 413                 &bit_store);
 414
 415
 416 /*
 417  * for(i = 0; i < data - data_start; i++)
 418  *      for(j = 0x80; j >= 1; j /= 2)
 419  *              printf("%d", (data_start[i] & j) ? 1 : 0);
 420  * printf("\n");
 421  */
 422
 423
 424
 425         return data - data_start;
 426 }
 427
 428
 429
 430 // Create the header for the esds block which is used in mp4v.
 431 // Taken from libavcodec
 432 // Returns the size
 433 static int write_mp4v_header(unsigned char *data,
 434         int w,
 435         int h,
 436         double frame_rate)
 437 {
 438         unsigned char *start = data;
 439
 440
 441 /*
 442  *      static unsigned char test[] =
 443  *      {
 444  *
 445  *              0x00, 0x00, 0x01, 0xb0, 0x01, 0x00, 0x00, 0x01, 0xb5, 0x89, 0x13,
 446  *              0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0xc4, 0x8d,
 447  *              0x8a, 0xee, 0x05, 0x28, 0x04, 0x5a, 0x14, 0x63, 0x00, 0x00, 0x01, 0xb2,
 448  *              0x46, 0x46, 0x6d, 0x70, 0x65, 0x67, 0x43, 0x56, 0x53, 0x62, 0x34, 0x37,
 449  *              0x35, 0x38
 450  *
 451  *      };
 452  *      memcpy(data, test, sizeof(test));
 453  *
 454  *      return sizeof(test);
 455  */
 456
 457 // From ffmpeg
 458 // Advanced simple level 1
 459 //      int profile_level = 0xf3;
 460
 461         int profile_level = 0x1;
 462 //      int vo_version_id = 5;
 463         int vo_version_id = 1;
 464
 465
 466
 467
 468
 469 // VOS startcode
 470         *data++ = 0x00;
 471         *data++ = 0x00;
 472         *data++ = 0x01;
 473         *data++ = 0xb0;
 474         *data++ = profile_level;
 475
 476 // Visual object startcode
 477         *data++ = 0x00;
 478         *data++ = 0x00;
 479         *data++ = 0x01;
 480         *data++ = 0xb5;
 481         *data++ = ((unsigned char)0x1 << 7) |
 482                 ((unsigned char)vo_version_id << 3) |
 483 // Priority
 484                 (unsigned char)1;
 485 // visual object type video
 486         *data++ = (0x1 << 4) |
 487 // Video signal type
 488                 (0 << 3) |
 489 // Stuffing
 490                 0x3;
 491
 492 //      *data++ = 0x40;
 493 //      *data++ = 0xc0;
 494 //      *data++ = 0xcf;
 495
 496 // video object
 497         int vol_size = quicktime_mpeg4_write_vol(data,
 498                 w,
 499                 h,
 500                 60000,
 501                 frame_rate);
 502         data += vol_size;
 503
 504         return data - start;
 505 }
 506
 507
 508
 509
 510
 511
 512
 513 // Mpeg-4 interface
 514
 515 static int reads_colormodel(quicktime_t *file,
 516                 int colormodel,
 517                 int track)
 518 {
 519         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
 520         quicktime_codec_t *codec = (quicktime_codec_t*)vtrack->codec;
 521         return (colormodel == BC_YUV420P &&
 522                 !quicktime_match_32(QUICKTIME_SVQ1, codec->fourcc));
 523 }
 524
 525 static int writes_colormodel(quicktime_t *file,
 526                 int colormodel,
 527                 int track)
 528 {
 529         return colormodel == BC_YUV420P;
 530 }
 531
 532
 533
 534 static int decode(quicktime_t *file, unsigned char **row_pointers, int track)
 535 {
 536         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
 537         quicktime_trak_t *trak = vtrack->track;
 538         quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
 539         quicktime_stsd_table_t *stsd_table = &trak->mdia.minf.stbl.stsd.table[0];
 540         int width = trak->tkhd.track_width;
 541         int height = trak->tkhd.track_height;
 542         int result = 0;
 543
 544
 545         if(!codec->decoder) codec->decoder = quicktime_new_ffmpeg(
 546                 file->cpus,
 547                 codec->total_fields,
 548                 codec->ffmpeg_id,
 549                 width,
 550                 height,
 551                 stsd_table);
 552
 553         if(codec->decoder) result = quicktime_ffmpeg_decode(
 554                 codec->decoder,
 555                 file,
 556                 row_pointers,
 557                 track);
 558
 559
 560         return result;
 561 }
 562
 563
 564 static int encode_video2(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 565                                              const AVFrame *pict)
 566 {
 567         AVPacket pkt;
 568         av_init_packet(&pkt);
 569         pkt.data = buf;
 570         pkt.size = buf_size;
 571
 572         int got_packet = 0;
 573         int ret = avcodec_encode_video2(avctx, &pkt, pict, &got_packet);
 574         if (!ret && got_packet && avctx->coded_frame) {
 575                 avctx->coded_frame->pts = pkt.pts;
 576                 avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
 577         }
 578
 579         if( pkt.side_data_elems > 0 ) {
 580                 int i = pkt.side_data_elems;
 581                 while( --i >= 0 ) av_free(pkt.side_data[i].data);
 582                 av_freep(&pkt.side_data);
 583                 pkt.side_data_elems = 0;
 584         }
 585
 586         return ret ? ret : pkt.size;
 587 }
 588
 589
 590 static void frame_defaults(AVFrame *frame)
 591 {
 592     memset(frame, 0, sizeof(AVFrame));
 593     av_frame_unref(frame);
 594 }
 595
 596
 597 static int encode(quicktime_t *file, unsigned char **row_pointers, int track)
 598 {
 599 //      int64_t offset = quicktime_position(file);
 600         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
 601         quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
 602         quicktime_trak_t *trak = vtrack->track;
 603         int width = trak->tkhd.track_width;
 604         int height = trak->tkhd.track_height;
 605         int width_i = quicktime_quantize16(width);
 606         int height_i = quicktime_quantize16(height);
 607         int result = 0;
 608         int i;
 609         int bytes = 0;
 610         int is_keyframe = 0;
 611         int current_field = vtrack->current_position % codec->total_fields;
 612         quicktime_atom_t chunk_atom;
 613
 614
 615
 616
 617
 618         pthread_mutex_lock(&ffmpeg_lock);
 619
 620
 621
 622         if(!codec->encode_initialized[current_field])
 623         {
 624 // Encore section
 625                 if(codec->ffmpeg_id == AV_CODEC_ID_MPEG4 && codec->use_encore)
 626                 {
 627                         codec->encode_initialized[current_field] = 1;
 628                         codec->encode_handle[current_field] = encode_handle++;
 629                         codec->enc_param[current_field].x_dim = width_i;
 630                         codec->enc_param[current_field].y_dim = height_i;
 631                         codec->enc_param[current_field].framerate =
 632                                 quicktime_frame_rate(file, track) / codec->total_fields;
 633                         codec->enc_param[current_field].bitrate =
 634                                 codec->bitrate / codec->total_fields;
 635                         codec->enc_param[current_field].rc_period = codec->rc_period;
 636                         codec->enc_param[current_field].rc_reaction_period = codec->rc_reaction_period;
 637                         codec->enc_param[current_field].rc_reaction_ratio = codec->rc_reaction_ratio;
 638                         codec->enc_param[current_field].max_quantizer = codec->max_quantizer;
 639                         codec->enc_param[current_field].min_quantizer = codec->min_quantizer;
 640                         codec->enc_param[current_field].max_key_interval = codec->max_key_interval;
 641
 642                         codec->enc_param[current_field].search_range = codec->quality * 3;
 643                         if(codec->enc_param[current_field].search_range > 15)
 644                                 codec->enc_param[current_field].search_range = 15;
 645
 646                         encore(codec->encode_handle[current_field],
 647                                 ENC_OPT_INIT,
 648                                 &codec->enc_param[current_field], NULL);
 649
 650                 }
 651                 else
 652 // ffmpeg section
 653                 {
 654                         codec->encode_initialized[current_field] = 1;
 655                         if(!ffmpeg_initialized)
 656                         {
 657                                 ffmpeg_initialized = 1;
 658                                 av_register_all();
 659                         }
 660
 661                         AVCodec *av_codec = avcodec_find_encoder(codec->ffmpeg_id);
 662                         codec->encoder[current_field] = av_codec;
 663
 664                         if(!codec->encoder[current_field])
 665                         {
 666                                 printf("encode: avcodec_find_encoder returned NULL.\n");
 667                                 pthread_mutex_unlock(&ffmpeg_lock);
 668                                 return 1;
 669                         }
 670
 671                         AVCodecContext *context = avcodec_alloc_context3(av_codec);
 672                         codec->encoder_context[current_field] = context;
 673
 674                         context->width = width_i;
 675                         context->height = height_i;
 676                         context->gop_size = codec->gop_size;
 677                         context->pix_fmt = PIX_FMT_YUV420P;
 678                         context->bit_rate = codec->bitrate / codec->total_fields;
 679                         context->bit_rate_tolerance = codec->bitrate_tolerance;
 680                         context->qmin =
 681                                 (!codec->fix_bitrate ? codec->quantizer : 2);
 682                         context->qmax =
 683                                 (!codec->fix_bitrate ? codec->quantizer : 31);
 684 // It needs the time per frame, not the frame rate.
 685                         context->time_base.den = quicktime_frame_rate_n(file, track);
 686                         context->time_base.num = quicktime_frame_rate_d(file, track);
 687
 688                         context->profile= FF_PROFILE_UNKNOWN;
 689                         context->level= FF_LEVEL_UNKNOWN;
 690 //                      context->flags |= CODEC_FLAG_H263P_UMV;
 691                         context->flags |= CODEC_FLAG_AC_PRED;
 692
 693                         if( codec->ffmpeg_id == AV_CODEC_ID_MPEG4 ||
 694                             codec->ffmpeg_id == AV_CODEC_ID_H263 ||
 695                             codec->ffmpeg_id == AV_CODEC_ID_H263P ||
 696                             codec->ffmpeg_id == AV_CODEC_ID_FLV1 )
 697                                 context->flags |= CODEC_FLAG_4MV;
 698
 699                         if( codec->ffmpeg_id == AV_CODEC_ID_MPEG4)
 700                                 context->flags |= CODEC_FLAG_QPEL;
 701
 702 // All the forbidden settings can be extracted from libavcodec/mpegvideo.c of ffmpeg...
 703
 704 // Not compatible with Win
 705 //                      context->flags |= CODEC_FLAG_QPEL;
 706
 707                         if(file->cpus > 1)
 708                         {
 709 //                              avcodec_thread_init(context, file->cpus);
 710                                 context->thread_count = file->cpus;
 711                         }
 712
 713                         if(!codec->fix_bitrate)
 714                                 context->flags |= CODEC_FLAG_QSCALE;
 715
 716                         if(codec->interlaced)
 717                         {
 718                                 context->flags |= CODEC_FLAG_INTERLACED_DCT;
 719                                 context->flags |= CODEC_FLAG_INTERLACED_ME;
 720                         }
 721
 722
 723 /*
 724  * printf("encode gop_size=%d fix_bitrate=%d quantizer=%d\n",
 725  * codec->gop_size,
 726  * codec->fix_bitrate,
 727  * codec->quantizer);
 728  */
 729                         avcodec_open2(context, codec->encoder[current_field], 0);
 730                         frame_defaults(&codec->picture[current_field]);
 731                 }
 732         }
 733
 734
 735         if(!codec->work_buffer)
 736         {
 737                 codec->buffer_size = width_i * height_i;
 738                 codec->work_buffer = malloc(codec->buffer_size);
 739         }
 740
 741
 742
 743 // Encore section
 744         if(codec->use_encore)
 745         {
 746 // Encore section
 747                 ENC_FRAME encore_input;
 748                 ENC_RESULT encore_result;
 749
 750
 751 // Assume planes are contiguous.
 752 // Encode directly from function arguments
 753                 if(file->color_model == BC_YUV420P &&
 754                         width == width_i &&
 755                         height == height_i)
 756                 {
 757                         encore_input.image = row_pointers[0];
 758                 }
 759 // Convert to YUV420P
 760 // Encode from temporary.
 761                 else
 762                 {
 763                         if(!codec->temp_frame)
 764                         {
 765                                 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
 766                         }
 767                         unsigned char *utmp_frame = (unsigned char *)codec->temp_frame;
 768                         cmodel_transfer(0, /* Leave NULL if non existent */
 769                                 row_pointers,
 770                                 utmp_frame, /* Leave NULL if non existent */
 771                                 utmp_frame + width_i * height_i,
 772                                 utmp_frame + width_i * height_i + width_i * height_i / 4,
 773                                 row_pointers[0], /* Leave NULL if non existent */
 774                                 row_pointers[1],
 775                                 row_pointers[2],
 776                                 0,        /* Dimensions to capture from input frame */
 777                                 0,
 778                                 width,
 779                                 height,
 780                                 0,       /* Dimensions to project on output frame */
 781                                 0,
 782                                 width,
 783                                 height,
 784                                 file->color_model,
 785                                 BC_YUV420P,
 786                                 0,         /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
 787                                 width,       /* For planar use the luma rowspan */
 788                                 width_i);
 789
 790
 791                         encore_input.image = codec->temp_frame;
 792                 }
 793
 794
 795
 796                 bzero(codec->work_buffer, codec->buffer_size);
 797                 encore_input.bitstream = codec->work_buffer;
 798                 encore_input.length = 0;
 799                 encore_input.quant = !codec->fix_bitrate ? codec->quantizer : 0;
 800
 801                 if(codec->p_count == 0)
 802                 {
 803                         codec->p_count[current_field]++;
 804                 }
 805                 else
 806                 {
 807                         codec->p_count[current_field]++;
 808                         if(codec->p_count[current_field] >= codec->max_key_interval)
 809                                 codec->p_count[current_field] = 0;
 810                 }
 811
 812
 813                 encore(codec->encode_handle[current_field],
 814                         0,
 815                         &encore_input,
 816                         &encore_result);
 817
 818                 bytes = encore_input.length;
 819                 is_keyframe = encore_result.isKeyFrame;
 820         }
 821         else
 822 // ffmpeg section
 823         {
 824                 AVCodecContext *context = codec->encoder_context[current_field];
 825                 AVFrame *picture = &codec->picture[current_field];
 826
 827                 if(width_i == width &&
 828                         height_i == height &&
 829                         file->color_model == BC_YUV420P)
 830                 {
 831                         picture->data[0] = row_pointers[0];
 832                         picture->data[1] = row_pointers[1];
 833                         picture->data[2] = row_pointers[2];
 834                         picture->linesize[0] = width_i;
 835                         picture->linesize[1] = width_i / 2;
 836                         picture->linesize[2] = width_i / 2;
 837                 }
 838                 else
 839                 {
 840                         if(!codec->temp_frame)
 841                         {
 842                                 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
 843                         }
 844                         unsigned char *utmp_frame = (unsigned char *)codec->temp_frame;
 845
 846                         cmodel_transfer(0, /* Leave NULL if non existent */
 847                                 row_pointers,
 848                                 utmp_frame, /* Leave NULL if non existent */
 849                                 utmp_frame + width_i * height_i,
 850                                 utmp_frame + width_i * height_i + width_i * height_i / 4,
 851                                 row_pointers[0], /* Leave NULL if non existent */
 852                                 row_pointers[1],
 853                                 row_pointers[2],
 854                                 0,        /* Dimensions to capture from input frame */
 855                                 0,
 856                                 width,
 857                                 height,
 858                                 0,       /* Dimensions to project on output frame */
 859                                 0,
 860                                 width,
 861                                 height,
 862                                 file->color_model,
 863                                 BC_YUV420P,
 864                                 0,         /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
 865                                 width,       /* For planar use the luma rowspan */
 866                                 width_i);
 867
 868                         picture->data[0] = utmp_frame;
 869                         picture->data[1] = utmp_frame + width_i * height_i;
 870                         picture->data[2] = utmp_frame + width_i * height_i + width_i * height_i / 4;
 871                         picture->linesize[0] = width_i;
 872                         picture->linesize[1] = width_i / 2;
 873                         picture->linesize[2] = width_i / 2;
 874                 }
 875
 876
 877                 picture->pict_type = 0;
 878                 picture->quality = 0;
 879                 picture->pts = vtrack->current_position * quicktime_frame_rate_d(file, track);
 880                 picture->key_frame = 0;
 881                 bytes = encode_video2(context, codec->work_buffer, codec->buffer_size, picture);
 882                 is_keyframe = context->coded_frame && context->coded_frame->key_frame;
 883 /*
 884  * printf("encode current_position=%d is_keyframe=%d\n",
 885  * vtrack->current_position,
 886  * is_keyframe);
 887  */
 888
 889                 if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
 890                         !strcmp(((quicktime_codec_t*)vtrack->codec)->fourcc, QUICKTIME_MP4V))
 891                 {
 892                         unsigned char temp[1024];
 893                         unsigned char *ptr = temp;
 894                         for(i = 0; i < bytes - 4; i++)
 895                         {
 896                                 if(!(codec->work_buffer[i] == 0x00 &&
 897                                         codec->work_buffer[i + 1] == 0x00 &&
 898                                         codec->work_buffer[i + 2] == 0x01 &&
 899                                         codec->work_buffer[i + 3] == 0xb3))
 900                                 {
 901                                         *ptr++ = codec->work_buffer[i];
 902                                 }
 903                                 else
 904                                         break;
 905                         }
 906                         quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0],
 907                                 temp,
 908                                 ptr - temp);
 909                         trak->mdia.minf.stbl.stsd.table[0].version = 0;
 910                 }
 911         }
 912
 913
 914
 915
 916
 917
 918         pthread_mutex_unlock(&ffmpeg_lock);
 919         quicktime_write_chunk_header(file, trak, &chunk_atom);
 920         result = !quicktime_write_data(file, (char*)codec->work_buffer, bytes);
 921         quicktime_write_chunk_footer(file, trak, vtrack->current_chunk, &chunk_atom, 1);
 922         if(is_keyframe || vtrack->current_position == 0)
 923                 quicktime_insert_keyframe(file, vtrack->current_position, track);
 924
 925         vtrack->current_chunk++;
 926         return result;
 927 }
 928
 929
 930
 931
 932
 933
 934 static void flush(quicktime_t *file, int track)
 935 {
 936         quicktime_video_map_t *track_map = &(file->vtracks[track]);
 937         quicktime_trak_t *trak = track_map->track;
 938
 939 // Create header
 940         if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
 941                 !strcmp(((quicktime_codec_t*)track_map->codec)->fourcc, QUICKTIME_MP4V))
 942         {
 943                 int width = trak->tkhd.track_width;
 944                 int height = trak->tkhd.track_height;
 945                 int width_i = quicktime_quantize16(width);
 946                 int height_i = quicktime_quantize16(height);
 947
 948                 unsigned char temp[1024];
 949                 int size = write_mp4v_header(temp, width_i, height_i,
 950                         quicktime_frame_rate(file, track));
 951                 quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0], temp, size);
 952         }
 953
 954 // Create udta
 955         file->moov.udta.require = strdup("QuickTime 6.0 or greater");
 956         file->moov.udta.require_len = strlen(file->moov.udta.require);
 957 }
 958
 959
 960
 961
 962
 963
 964
 965
 966 static int set_parameter(quicktime_t *file,
 967                 int track,
 968                 char *key,
 969                 void *value)
 970 {
 971         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
 972         char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
 973
 974         if(quicktime_match_32(compressor, QUICKTIME_DIVX) ||
 975                 quicktime_match_32(compressor, QUICKTIME_MP42) ||
 976                 quicktime_match_32(compressor, QUICKTIME_MPG4) ||
 977                 quicktime_match_32(compressor, QUICKTIME_DX50) ||
 978                 quicktime_match_32(compressor, QUICKTIME_HV60))
 979         {
 980                 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
 981
 982                 if(!strcasecmp(key, "divx_bitrate"))
 983                         codec->bitrate = *(int*)value;
 984                 else
 985                 if(!strcasecmp(key, "divx_rc_period"))
 986                         codec->rc_period = *(int*)value;
 987                 else
 988                 if(!strcasecmp(key, "divx_rc_reaction_ratio"))
 989                         codec->rc_reaction_ratio = *(int*)value;
 990                 else
 991                 if(!strcasecmp(key, "divx_rc_reaction_period"))
 992                         codec->rc_reaction_period = *(int*)value;
 993                 else
 994                 if(!strcasecmp(key, "divx_max_key_interval"))
 995                         codec->max_key_interval = *(int*)value;
 996                 else
 997                 if(!strcasecmp(key, "divx_max_quantizer"))
 998                         codec->max_quantizer = *(int*)value;
 999                 else
1000                 if(!strcasecmp(key, "divx_min_quantizer"))
1001                         codec->min_quantizer = *(int*)value;
1002                 else
1003                 if(!strcasecmp(key, "divx_quantizer"))
1004                         codec->quantizer = *(int*)value;
1005                 else
1006                 if(!strcasecmp(key, "divx_quality"))
1007                         codec->quality = *(int*)value;
1008                 else
1009                 if(!strcasecmp(key, "divx_fix_bitrate"))
1010                         codec->fix_bitrate = *(int*)value;
1011                 else
1012                 if(!strcasecmp(key, "divx_use_deblocking"))
1013                         codec->use_deblocking = *(int*)value;
1014         }
1015         else
1016         if(quicktime_match_32(compressor, QUICKTIME_DIV3) ||
1017                 quicktime_match_32(compressor, QUICKTIME_MP4V))
1018         {
1019                 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1020                 if(!strcasecmp(key, "ffmpeg_bitrate"))
1021                         codec->bitrate = *(int*)value;
1022                 else
1023                 if(!strcasecmp(key, "ffmpeg_bitrate_tolerance"))
1024                         codec->bitrate_tolerance = *(int*)value;
1025                 else
1026                 if(!strcasecmp(key, "ffmpeg_interlaced"))
1027                         codec->interlaced = *(int*)value;
1028                 else
1029                 if(!strcasecmp(key, "ffmpeg_gop_size"))
1030                         codec->gop_size = *(int*)value;
1031                 else
1032                 if(!strcasecmp(key, "ffmpeg_quantizer"))
1033                         codec->quantizer = *(int*)value;
1034                 else
1035                 if(!strcasecmp(key, "ffmpeg_fix_bitrate"))
1036                         codec->fix_bitrate = *(int*)value;
1037         }
1038         return 0;
1039 }
1040
1041
1042
1043 static void delete_codec(quicktime_video_map_t *vtrack)
1044 {
1045         quicktime_mpeg4_codec_t *codec;
1046         int i;
1047
1048
1049         codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1050         for(i = 0; i < codec->total_fields; i++)
1051         {
1052                 if(codec->encode_initialized[i])
1053                 {
1054                         pthread_mutex_lock(&ffmpeg_lock);
1055                         if(codec->use_encore)
1056                         {
1057                                 encore(codec->encode_handle[i],
1058                                         ENC_OPT_RELEASE,
1059                                         0,
1060                                         0);
1061                         }
1062                         else
1063                         {
1064                         avcodec_close(codec->encoder_context[i]);
1065                                 free(codec->encoder_context[i]);
1066                         }
1067                         pthread_mutex_unlock(&ffmpeg_lock);
1068                 }
1069         }
1070
1071
1072         if(codec->temp_frame) free(codec->temp_frame);
1073         if(codec->work_buffer) free(codec->work_buffer);
1074         if(codec->decoder) quicktime_delete_ffmpeg(codec->decoder);
1075
1076         free(codec);
1077 }
1078
1079
1080
1081
1082 static quicktime_mpeg4_codec_t* init_common(quicktime_video_map_t *vtrack,
1083         char *compressor,
1084         char *title,
1085         char *description)
1086 {
1087         quicktime_codec_t *codec_base = (quicktime_codec_t*)vtrack->codec;
1088         quicktime_mpeg4_codec_t *codec;
1089
1090         codec_base->priv = calloc(1, sizeof(quicktime_mpeg4_codec_t));
1091         codec_base->delete_vcodec = delete_codec;
1092         codec_base->decode_video = decode;
1093         codec_base->encode_video = encode;
1094         codec_base->flush = flush;
1095         codec_base->reads_colormodel = reads_colormodel;
1096         codec_base->writes_colormodel = writes_colormodel;
1097         codec_base->set_parameter = set_parameter;
1098         codec_base->fourcc = compressor;
1099         codec_base->title = title;
1100         codec_base->desc = description;
1101
1102         codec = (quicktime_mpeg4_codec_t*)codec_base->priv;
1103
1104
1105
1106 // Set defaults
1107         codec->bitrate = 1000000;
1108         codec->bitrate_tolerance = 1000000;
1109         codec->rc_period = 50;
1110         codec->rc_reaction_ratio = 45;
1111         codec->rc_reaction_period = 10;
1112         codec->max_key_interval = 45;
1113         codec->max_quantizer = 31;
1114         codec->min_quantizer = 1;
1115         codec->quantizer = 10;
1116         codec->quality = 5;
1117         codec->fix_bitrate = 1;
1118         codec->total_fields = 1;
1119
1120
1121
1122         return codec;
1123 }
1124
1125
1126
1127
1128 // Mike Rowe Soft MPEG-4
1129 void quicktime_init_codec_div3(quicktime_video_map_t *vtrack)
1130 {
1131         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1132                 QUICKTIME_DIV3,
1133                 "DIVX",
1134                 "Mike Row Soft MPEG4 Version 3");
1135         result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V3;
1136 }
1137
1138 void quicktime_init_codec_div5(quicktime_video_map_t *vtrack)
1139 {
1140         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1141                 QUICKTIME_DX50,
1142                 "DIVX",
1143                 "Mike Row Soft MPEG4 Version 5");
1144         result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1145 }
1146
1147 // Mike Rowe Soft MPEG-4
1148 void quicktime_init_codec_div3lower(quicktime_video_map_t *vtrack)
1149 {
1150         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1151                 QUICKTIME_DIV3_LOWER,
1152                 "DIVX",
1153                 "Mike Row Soft MPEG4 Version 3");
1154         result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V3;
1155 }
1156
1157 void quicktime_init_codec_div3v2(quicktime_video_map_t *vtrack)
1158 {
1159         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1160                 QUICKTIME_MP42,
1161                 "MP42",
1162                 "Mike Row Soft MPEG4 Version 2");
1163         result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V2;
1164 }
1165
1166 // Generic MPEG-4
1167 void quicktime_init_codec_divx(quicktime_video_map_t *vtrack)
1168 {
1169         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1170                 QUICKTIME_DIVX,
1171                 "MPEG-4",
1172                 "Generic MPEG Four");
1173         result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1174         result->use_encore = 1;
1175 }
1176
1177 void quicktime_init_codec_mpg4(quicktime_video_map_t *vtrack)
1178 {
1179         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1180                 QUICKTIME_MPG4,
1181                 "MPEG-4",
1182                 "FFMPEG (msmpeg4)");
1183         result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V1;
1184 }
1185
1186 void quicktime_init_codec_dx50(quicktime_video_map_t *vtrack)
1187 {
1188         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1189                 QUICKTIME_DX50,
1190                 "MPEG-4",
1191                 "FFMPEG (mpeg4)");
1192         result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1193 }
1194
1195 // Generic MPEG-4
1196 void quicktime_init_codec_mp4v(quicktime_video_map_t *vtrack)
1197 {
1198         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1199                 QUICKTIME_MP4V,
1200                 "MPEG4",
1201                 "Generic MPEG Four");
1202         result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1203 //      result->use_encore = 1;
1204 }
1205
1206
1207 // Mormon MPEG-4
1208 void quicktime_init_codec_svq1(quicktime_video_map_t *vtrack)
1209 {
1210         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1211                 QUICKTIME_SVQ1,
1212                 "Sorenson Version 1",
1213                 "From the chearch of codecs of yesterday's sights");
1214         result->ffmpeg_id = AV_CODEC_ID_SVQ1;
1215 }
1216
1217 void quicktime_init_codec_svq3(quicktime_video_map_t *vtrack)
1218 {
1219         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1220                 QUICKTIME_SVQ3,
1221                 "Sorenson Version 3",
1222                 "From the chearch of codecs of yesterday's sights");
1223         result->ffmpeg_id = AV_CODEC_ID_SVQ3;
1224 }
1225
1226 void quicktime_init_codec_h263(quicktime_video_map_t *vtrack)
1227 {
1228     quicktime_mpeg4_codec_t *result = init_common(vtrack,
1229         QUICKTIME_H263,
1230         "H.263",
1231         "H.263");
1232     result->ffmpeg_id = AV_CODEC_ID_H263;
1233 }
1234
1235 void quicktime_init_codec_xvid(quicktime_video_map_t *vtrack)
1236 {
1237     quicktime_mpeg4_codec_t *result = init_common(vtrack,
1238         QUICKTIME_XVID,
1239         "XVID",
1240         "FFmpeg MPEG-4");
1241     result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1242 }
1243
1244 void quicktime_init_codec_dnxhd(quicktime_video_map_t *vtrack)
1245 {
1246     quicktime_mpeg4_codec_t *result = init_common(vtrack,
1247         QUICKTIME_DNXHD,
1248         "DNXHD",
1249         "DNXHD");
1250     result->ffmpeg_id = AV_CODEC_ID_DNXHD;
1251 }
1252
1253 // field based MPEG-4
1254 void quicktime_init_codec_hv60(quicktime_video_map_t *vtrack)
1255 {
1256         quicktime_mpeg4_codec_t *result = init_common(vtrack,
1257                 QUICKTIME_HV60,
1258                 "Dual MPEG-4",
1259                 "MPEG 4 with alternating streams every other frame.  (Not standardized)");
1260         result->total_fields = 2;
1261         result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1262 }
1263
1264
1265
1266
1267
1268