Cinelerra: hvirtual/quicktime/mpeg4.c Source File

00001 /* General codec for all MPEG-4 derived encoding. */
00002 /* Uses ffmpeg and encore50. */
00003 /* Encore50 still seemed to provide better results than ffmpeg for encoding */
00004 /* so it does all the generic MPEG-4 encoding. */
00005 
00006 
00007 
00008 
00009 
00010 #include "avcodec.h"
00011 #include "colormodels.h"
00012 #include "funcprotos.h"
00013 #include "qtffmpeg.h"
00014 #include "quicktime.h"
00015 #include "workarounds.h"
00016 #include ENCORE_INCLUDE
00017 //#include DECORE_INCLUDE
00018 
00019 
00020 
00021 #include <pthread.h>
00022 #include <stdint.h>
00023 #include <stdlib.h>
00024 #include <string.h>
00025 
00026 #define FRAME_RATE_BASE 10000
00027 #define FIELDS 2
00028 
00029 
00030 typedef struct
00031 {
00032 
00033 // Decoder side
00034         quicktime_ffmpeg_t *decoder;
00035 
00036 
00037 
00038 
00039 
00040 
00041 
00042 
00043 
00044 // Encoding side
00045         int encode_initialized[FIELDS];
00046 // Information for picking the right library routines.
00047 // ID out of avcodec.h for the codec used.
00048 // Invalid if encore50 is used.
00049         int ffmpeg_id;
00050 // True if encore50 is being used.
00051         int use_encore;
00052 
00053 // FFMpeg internals
00054     AVCodec *encoder[FIELDS];
00055         AVCodecContext *encoder_context[FIELDS];
00056     AVFrame picture[FIELDS];
00057         
00058 
00059 // Encore internals
00060         int encode_handle[FIELDS];
00061         ENC_PARAM enc_param[FIELDS];
00062 // Must count pframes in VBR
00063         int p_count[FIELDS];
00064 
00065 
00066 // Encoding parameters
00067         int bitrate;
00068 // For heroine 60 encoding, we want different streams for each field.
00069         int total_fields;
00070         long rc_period;          // the intended rate control averaging period
00071         long rc_reaction_period; // the reation period for rate control
00072         long rc_reaction_ratio;  // the ratio for down/up rate control
00073         long max_key_interval;   // the maximum interval between key frames
00074         int bitrate_tolerance;
00075         int interlaced;
00076         int gop_size;
00077         int max_quantizer;       // the upper limit of the quantizer
00078         int min_quantizer;       // the lower limit of the quantizer
00079         int quantizer;           // For vbr
00080         int quality;             // the forward search range for motion estimation
00081         int fix_bitrate;
00082         int use_deblocking;
00083 
00084 
00085 // Temporary storage for color conversions
00086         char *temp_frame;
00087 // Storage of compressed data
00088         unsigned char *work_buffer;
00089 // Allocation of work_buffer
00090         int buffer_size;
00091 } quicktime_mpeg4_codec_t;
00092 
00093 
00094 
00095 // Decore needs the user to specify handles
00096 static int decode_handle = 1;
00097 static int encode_handle = 0;
00098 
00099 
00100 
00101 
00102 
00103 
00104 
00105 
00106 
00107 // Direct copy routines
00108 
00109 
00110 // Determine of the compressed frame is a keyframe for direct copy
00111 int quicktime_mpeg4_is_key(unsigned char *data, long size, char *codec_id)
00112 {
00113         int result = 0;
00114         int i;
00115 
00116         if(quicktime_match_32(codec_id, QUICKTIME_DIVX) ||
00117                 quicktime_match_32(codec_id, QUICKTIME_MP4V) ||
00118                 quicktime_match_32(codec_id, QUICKTIME_HV60))
00119         {
00120                 for(i = 0; i < size - 5; i++)
00121                 {
00122                         if( data[i]     == 0x00 && 
00123                                 data[i + 1] == 0x00 &&
00124                                 data[i + 2] == 0x01 &&
00125                                 data[i + 3] == 0xb6)
00126                         {
00127                                 if((data[i + 4] & 0xc0) == 0x0) 
00128                                         return 1;
00129                                 else
00130                                         return 0;
00131                         }
00132                 }
00133         }
00134         return result;
00135 }
00136 
00137 
00138 // Test for VOL header in frame
00139 int quicktime_mpeg4_has_vol(unsigned char *data)
00140 {
00141         if( data[0] == 0x00 &&
00142                 data[1] == 0x00 &&
00143                 data[2] == 0x01 &&
00144                 data[3] == 0x00 &&
00145                 data[4] == 0x00 &&
00146                 data[5] == 0x00 &&
00147                 data[6] == 0x01 &&
00148                 data[7] == 0x20)
00149                 return 1;
00150         else
00151                 return 0;
00152 }
00153 
00154 
00155 
00156 
00157 static void putbits(unsigned char **data, 
00158         int *bit_pos, 
00159         uint64_t *bit_store, 
00160         int *total, 
00161         int count, 
00162         uint64_t value)
00163 {
00164         value &= 0xffffffffffffffffLL >> (64 - count);
00165 
00166         while(64 - *bit_pos < count)
00167         {
00168                 *(*data)++ = (*bit_store) >> 56;
00169                 (*bit_store) <<= 8;
00170                 (*bit_pos) -= 8;
00171         }
00172 
00173         (*bit_store) |= value << (64 - count - *bit_pos);
00174         (*bit_pos) += count;
00175         (*total) += count;
00176 }
00177 
00178 
00179 static void flushbits(unsigned char **data, 
00180         int *bit_pos, 
00181         uint64_t *bit_store)
00182 {
00183 //printf("flushbits %llx\n", (*bit_store));
00184         while((*bit_pos) > 0)
00185         {
00186                 *(*data)++ = (*bit_store) >> 56;
00187                 (*bit_store) <<= 8;
00188                 (*bit_pos) -= 8;
00189         }
00190 }
00191 
00192 
00193 
00194 
00195 #define VO_START_CODE           0x8      
00196 #define VO_START_CODE_LENGTH    27
00197 #define VOL_START_CODE 0x12             /* 25-MAR-97 JDL : according to WD2 */
00198 #define VOL_START_CODE_LENGTH 28
00199 
00200 
00201 
00202 int quicktime_mpeg4_write_vol(unsigned char *data_start,
00203         int vol_width, 
00204         int vol_height, 
00205         int time_increment_resolution, 
00206         double frame_rate)
00207 {
00208         int written = 0;
00209         int bits, fixed_vop_time_increment;
00210         unsigned char *data = data_start;
00211         int bit_pos;
00212         uint64_t bit_store;
00213         int i, j;
00214 
00215         bit_store = 0;
00216         bit_pos = 0;
00217         vol_width = quicktime_quantize16(vol_width);
00218         vol_height = quicktime_quantize16(vol_height);
00219 
00220 
00221         putbits(&data, 
00222                 &bit_pos, 
00223                 &bit_store, 
00224                 &written,
00225                 VO_START_CODE_LENGTH, VO_START_CODE);
00226         putbits(&data, 
00227                 &bit_pos, 
00228                 &bit_store, 
00229                 &written,
00230                 5, 0);                          /* vo_id = 0                                                            */
00231 
00232         putbits(&data, 
00233                 &bit_pos, 
00234                 &bit_store, 
00235                 &written,
00236                 VOL_START_CODE_LENGTH, VOL_START_CODE);
00237 
00238 
00239 
00240         putbits(&data, 
00241                 &bit_pos, 
00242                 &bit_store, 
00243                 &written,
00244                 4, 0);                          /* vol_id = 0                                                           */
00245 
00246         putbits(&data, 
00247                 &bit_pos, 
00248                 &bit_store, 
00249                 &written,
00250                 1, 0);                          /* random_accessible_vol = 0                            */
00251         putbits(&data, 
00252                 &bit_pos, 
00253                 &bit_store, 
00254                 &written,
00255                 8, 1);                          /* video_object_type_indication = 1 video       */
00256         putbits(&data, 
00257                 &bit_pos, 
00258                 &bit_store, 
00259                 &written,
00260                 1, 1);                          /* is_object_layer_identifier = 1                       */
00261         putbits(&data, 
00262                 &bit_pos, 
00263                 &bit_store, 
00264                 &written,
00265                 4, 2);                          /* visual_object_layer_ver_id = 2                       */
00266         putbits(&data, 
00267                 &bit_pos, 
00268                 &bit_store, 
00269                 &written,
00270                 3, 1);                          /* visual_object_layer_priority = 1                     */
00271         putbits(&data, 
00272                 &bit_pos, 
00273                 &bit_store, 
00274                 &written,
00275                 4, 1);                          /* aspect_ratio_info = 1                                        */
00276 
00277 
00278 
00279 
00280 
00281 
00282 
00283         putbits(&data, 
00284                 &bit_pos, 
00285                 &bit_store, 
00286                 &written,
00287                 1, 0);                          /* vol_control_parameter = 0                            */
00288         putbits(&data, 
00289                 &bit_pos, 
00290                 &bit_store, 
00291                 &written,
00292                 2, 0);                          /* vol_shape = 0 rectangular                            */
00293         putbits(&data, 
00294                 &bit_pos, 
00295                 &bit_store, 
00296                 &written,
00297                 1, 1);                          /* marker                                                                       */
00298 
00299 
00300 
00301 
00302 
00303 
00304 
00305         putbits(&data, 
00306                 &bit_pos, 
00307                 &bit_store, 
00308                 &written,
00309                 16, time_increment_resolution);
00310         putbits(&data, 
00311                 &bit_pos, 
00312                 &bit_store, 
00313                 &written,
00314                 1, 1);                          /* marker                                                                       */
00315         putbits(&data, 
00316                 &bit_pos, 
00317                 &bit_store, 
00318                 &written,
00319                 1, 1);                          /* fixed_vop_rate = 1                                           */
00320 
00321 
00322         bits = 1;
00323         while((1 << bits) < time_increment_resolution) bits++;
00324 
00325 // Log calculation fails for some reason
00326 //      bits = (int)ceil(log((double)time_increment_resolution) / log(2.0));
00327 //    if (bits < 1) bits=1;
00328 
00329         fixed_vop_time_increment = 
00330                 (int)(time_increment_resolution / frame_rate + 0.1);
00331 
00332         putbits(&data, 
00333                 &bit_pos, 
00334                 &bit_store, 
00335                 &written,
00336                 bits, fixed_vop_time_increment);
00337 
00338         putbits(&data, 
00339                 &bit_pos, 
00340                 &bit_store, 
00341                 &written,
00342                 1, 1);                          /* marker                                                                       */
00343 
00344         putbits(&data, 
00345                 &bit_pos, 
00346                 &bit_store, 
00347                 &written,
00348                 13, vol_width);
00349         putbits(&data, 
00350                 &bit_pos, 
00351                 &bit_store, 
00352                 &written,
00353                 1, 1);                          /* marker                                                                       */
00354         putbits(&data, 
00355                 &bit_pos, 
00356                 &bit_store, 
00357                 &written,
00358                 13, vol_height);
00359         putbits(&data, 
00360                 &bit_pos, 
00361                 &bit_store, 
00362                 &written,
00363                 1, 1);                          /* marker                                                                       */
00364 
00365         putbits(&data, 
00366                 &bit_pos, 
00367                 &bit_store, 
00368                 &written,
00369                 1, 0);                          /* interlaced = 0                                                       */
00370         putbits(&data, 
00371                 &bit_pos, 
00372                 &bit_store, 
00373                 &written,
00374                 1, 1);                          /* OBMC_disabled = 1                                            */
00375         putbits(&data, 
00376                 &bit_pos, 
00377                 &bit_store, 
00378                 &written,
00379                 2, 0);                          /* vol_sprite_usage = 0                                         */
00380         putbits(&data, 
00381                 &bit_pos, 
00382                 &bit_store, 
00383                 &written,
00384                 1, 0);                          /* not_8_bit = 0                                                        */
00385 
00386         putbits(&data, 
00387                 &bit_pos, 
00388                 &bit_store, 
00389                 &written,
00390                 1, 0);                          /* vol_quant_type = 0                                           */
00391         putbits(&data, 
00392                 &bit_pos, 
00393                 &bit_store, 
00394                 &written,
00395                 1, 0);                          /* vol_quarter_pixel = 0                                        */
00396         putbits(&data, 
00397                 &bit_pos, 
00398                 &bit_store, 
00399                 &written,
00400                 1, 1);                          /* complexity_estimation_disabled = 1           */
00401         putbits(&data, 
00402                 &bit_pos, 
00403                 &bit_store, 
00404                 &written,
00405                 1, 1);                          /* resync_marker_disabled = 1                           */
00406         putbits(&data, 
00407                 &bit_pos, 
00408                 &bit_store, 
00409                 &written,
00410                 1, 0);                          /* data_partitioning_enabled = 0                        */
00411         putbits(&data, 
00412                 &bit_pos, 
00413                 &bit_store, 
00414                 &written,
00415                 1, 0);                          /* scalability = 0                                                      */
00416 
00417         flushbits(&data, 
00418                 &bit_pos,
00419                 &bit_store);
00420 
00421 
00422 /*
00423  * for(i = 0; i < data - data_start; i++)
00424  *      for(j = 0x80; j >= 1; j /= 2)
00425  *              printf("%d", (data_start[i] & j) ? 1 : 0);
00426  * printf("\n");
00427  */
00428 
00429 
00430 
00431         return data - data_start;
00432 }
00433 
00434 
00435 
00436 // Create the header for the esds block which is used in mp4v.
00437 // Taken from libavcodec
00438 // Returns the size
00439 static int write_mp4v_header(unsigned char *data,
00440         int w, 
00441         int h,
00442         double frame_rate)
00443 {
00444         unsigned char *start = data;
00445 
00446 
00447 /*
00448  *      static unsigned char test[] = 
00449  *      {
00450  * 
00451  *              0x00, 0x00, 0x01, 0xb0, 0x01, 0x00, 0x00, 0x01, 0xb5, 0x89, 0x13,
00452  *              0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0xc4, 0x8d,
00453  *              0x8a, 0xee, 0x05, 0x28, 0x04, 0x5a, 0x14, 0x63, 0x00, 0x00, 0x01, 0xb2,
00454  *              0x46, 0x46, 0x6d, 0x70, 0x65, 0x67, 0x43, 0x56, 0x53, 0x62, 0x34, 0x37,
00455  *              0x35, 0x38
00456  * 
00457  *      };
00458  *      memcpy(data, test, sizeof(test));
00459  * 
00460  *      return sizeof(test);
00461  */
00462 
00463 // From ffmpeg
00464 // Advanced simple level 1
00465 //      int profile_level = 0xf3;
00466 
00467         int profile_level = 0x1;
00468 //      int vo_version_id = 5;
00469         int vo_version_id = 1;
00470 
00471 
00472 
00473 
00474 
00475 // VOS startcode
00476         *data++ = 0x00;
00477         *data++ = 0x00;
00478         *data++ = 0x01;
00479         *data++ = 0xb0;
00480         *data++ = profile_level;
00481 
00482 // Visual object startcode
00483         *data++ = 0x00;
00484         *data++ = 0x00;
00485         *data++ = 0x01;
00486         *data++ = 0xb5;
00487         *data++ = ((unsigned char)0x1 << 7) |
00488                 ((unsigned char)vo_version_id << 3) |
00489 // Priority
00490                 (unsigned char)1;
00491 // visual object type video
00492         *data++ = (0x1 << 4) |
00493 // Video signal type
00494                 (0 << 3) |
00495 // Stuffing
00496                 0x3;
00497 
00498 //      *data++ = 0x40;
00499 //      *data++ = 0xc0;
00500 //      *data++ = 0xcf;
00501 
00502 // video object
00503         int vol_size = quicktime_mpeg4_write_vol(data,
00504                 w, 
00505                 h, 
00506                 60000, 
00507                 frame_rate);
00508         data += vol_size;
00509 
00510         return data - start;
00511 }
00512 
00513 
00514 
00515 
00516 
00517 
00518 
00519 // Mpeg-4 interface
00520 
00521 static int reads_colormodel(quicktime_t *file, 
00522                 int colormodel, 
00523                 int track)
00524 {
00525         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
00526         quicktime_codec_t *codec = (quicktime_codec_t*)vtrack->codec;
00527         return (colormodel == BC_YUV420P && 
00528                 !quicktime_match_32(QUICKTIME_SVQ1, codec->fourcc));
00529 }
00530 
00531 static int writes_colormodel(quicktime_t *file, 
00532                 int colormodel, 
00533                 int track)
00534 {
00535         return colormodel == BC_YUV420P;
00536 }
00537 
00538 
00539 
00540 static int decode(quicktime_t *file, unsigned char **row_pointers, int track)
00541 {
00542         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
00543         quicktime_trak_t *trak = vtrack->track;
00544         quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
00545         quicktime_stsd_table_t *stsd_table = &trak->mdia.minf.stbl.stsd.table[0];
00546         int width = trak->tkhd.track_width;
00547         int height = trak->tkhd.track_height;
00548         int result = 0;
00549 
00550 
00551         if(!codec->decoder) codec->decoder = quicktime_new_ffmpeg(
00552                 file->cpus,
00553                 codec->total_fields,
00554                 codec->ffmpeg_id,
00555                 width,
00556                 height,
00557                 stsd_table);
00558 
00559         if(codec->decoder) result = quicktime_ffmpeg_decode(
00560                 codec->decoder,
00561                 file, 
00562                 row_pointers, 
00563                 track);
00564 
00565 
00566         return result;
00567 }
00568 
00569 
00570 static int encode(quicktime_t *file, unsigned char **row_pointers, int track)
00571 {
00572         int64_t offset = quicktime_position(file);
00573         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
00574         quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
00575         quicktime_trak_t *trak = vtrack->track;
00576         int width = trak->tkhd.track_width;
00577         int height = trak->tkhd.track_height;
00578         int width_i = quicktime_quantize16(width);
00579         int height_i = quicktime_quantize16(height);
00580         int result = 0;
00581         int i;
00582         int bytes = 0;
00583         int is_keyframe = 0;
00584         int current_field = vtrack->current_position % codec->total_fields;
00585         quicktime_atom_t chunk_atom;
00586 
00587 
00588 
00589 
00590 
00591         pthread_mutex_lock(&ffmpeg_lock);
00592 
00593 
00594 
00595         if(!codec->encode_initialized[current_field])
00596         {
00597 // Encore section
00598                 if(codec->ffmpeg_id == CODEC_ID_MPEG4 && codec->use_encore)
00599                 {
00600                         codec->encode_initialized[current_field] = 1;
00601                         codec->encode_handle[current_field] = encode_handle++;
00602                         codec->enc_param[current_field].x_dim = width_i;
00603                         codec->enc_param[current_field].y_dim = height_i;
00604                         codec->enc_param[current_field].framerate = 
00605                                 quicktime_frame_rate(file, track) / codec->total_fields;
00606                         codec->enc_param[current_field].bitrate = 
00607                                 codec->bitrate / codec->total_fields;
00608                         codec->enc_param[current_field].rc_period = codec->rc_period;
00609                         codec->enc_param[current_field].rc_reaction_period = codec->rc_reaction_period;
00610                         codec->enc_param[current_field].rc_reaction_ratio = codec->rc_reaction_ratio;
00611                         codec->enc_param[current_field].max_quantizer = codec->max_quantizer;
00612                         codec->enc_param[current_field].min_quantizer = codec->min_quantizer;
00613                         codec->enc_param[current_field].max_key_interval = codec->max_key_interval;
00614 
00615                         codec->enc_param[current_field].search_range = codec->quality * 3;
00616                         if(codec->enc_param[current_field].search_range > 15)
00617                                 codec->enc_param[current_field].search_range = 15;
00618 
00619                         encore(codec->encode_handle[current_field], 
00620                                 ENC_OPT_INIT, 
00621                                 &codec->enc_param[current_field], NULL);
00622 
00623                 }
00624                 else
00625 // ffmpeg section
00626                 {
00627                         static char *video_rc_eq="tex^qComp";
00628                         codec->encode_initialized[current_field] = 1;
00629                         if(!ffmpeg_initialized)
00630                         {
00631                                 ffmpeg_initialized = 1;
00632                                 avcodec_init();
00633                                 avcodec_register_all();
00634                         }
00635 
00636                         codec->encoder[current_field] = avcodec_find_encoder(codec->ffmpeg_id);
00637                         if(!codec->encoder[current_field])
00638                         {
00639                                 printf("encode: avcodec_find_encoder returned NULL.\n");
00640                                 pthread_mutex_unlock(&ffmpeg_lock);
00641                                 return 1;
00642                         }
00643 
00644                         codec->encoder_context[current_field] = avcodec_alloc_context();
00645                         AVCodecContext *context = codec->encoder_context[current_field];
00646 
00647                         context->width = width_i;
00648                         context->height = height_i;
00649                         context->gop_size = codec->gop_size;
00650                         context->pix_fmt = PIX_FMT_YUV420P;
00651                         context->bit_rate = codec->bitrate / codec->total_fields;
00652                         context->bit_rate_tolerance = codec->bitrate_tolerance;
00653                         context->rc_eq = video_rc_eq;
00654                 context->rc_max_rate = 0;
00655                 context->rc_min_rate = 0;
00656                 context->rc_buffer_size = 0;
00657                         context->qmin = 
00658                                 (!codec->fix_bitrate ? codec->quantizer : 2);
00659                         context->qmax = 
00660                                 (!codec->fix_bitrate ? codec->quantizer : 31);
00661                         context->lmin = 2 * FF_QP2LAMBDA;
00662                         context->lmax = 31 * FF_QP2LAMBDA;
00663                         context->mb_lmin = 2 * FF_QP2LAMBDA;
00664                         context->mb_lmax = 31 * FF_QP2LAMBDA;
00665                         context->max_qdiff = 3;
00666                         context->qblur = 0.5;
00667                         context->qcompress = 0.5;
00668 // It needs the time per frame, not the frame rate.
00669                         context->time_base.den = quicktime_frame_rate_n(file, track);
00670                         context->time_base.num = quicktime_frame_rate_d(file, track);
00671 
00672                 context->b_quant_factor = 1.25;
00673                 context->b_quant_offset = 1.25;
00674                         context->error_resilience = FF_ER_CAREFUL;
00675                         context->error_concealment = 3;
00676                         context->frame_skip_cmp = FF_CMP_DCTMAX;
00677                         context->ildct_cmp = FF_CMP_VSAD;
00678                         context->intra_dc_precision = 0;
00679                 context->intra_quant_bias = FF_DEFAULT_QUANT_BIAS;
00680                 context->inter_quant_bias = FF_DEFAULT_QUANT_BIAS;
00681                 context->i_quant_factor = -0.8;
00682                 context->i_quant_offset = 0.0;
00683                         context->mb_decision = FF_MB_DECISION_SIMPLE;
00684                         context->mb_cmp = FF_CMP_SAD;
00685                         context->me_sub_cmp = FF_CMP_SAD;
00686                         context->me_cmp = FF_CMP_SAD;
00687                         context->me_pre_cmp = FF_CMP_SAD;
00688                         context->me_method = ME_EPZS;
00689                         context->me_subpel_quality = 8;
00690                         context->me_penalty_compensation = 256;
00691                         context->me_range = 0;
00692                         context->me_threshold = 0;
00693                         context->mb_threshold = 0;
00694                         context->nsse_weight= 8;
00695                 context->profile= FF_PROFILE_UNKNOWN;
00696                         context->rc_buffer_aggressivity = 1.0;
00697                 context->level= FF_LEVEL_UNKNOWN;
00698                         context->flags |= CODEC_FLAG_H263P_UMV;
00699                         context->flags |= CODEC_FLAG_AC_PRED;
00700 
00701 // All the forbidden settings can be extracted from libavcodec/mpegvideo.c of ffmpeg...
00702                         
00703 // Copyed from ffmpeg's mpegvideo.c... set 4MV only where it is supported
00704                         if(codec->ffmpeg_id == CODEC_ID_MPEG4 ||
00705                            codec->ffmpeg_id == CODEC_ID_H263 ||
00706                            codec->ffmpeg_id == CODEC_ID_H263P ||
00707                            codec->ffmpeg_id == CODEC_ID_FLV1)
00708                                 context->flags |= CODEC_FLAG_4MV;
00709 // Not compatible with Win
00710 //                      context->flags |= CODEC_FLAG_QPEL;
00711 
00712                         if(file->cpus > 1 && 
00713                                 (codec->ffmpeg_id == CODEC_ID_MPEG4 ||
00714                                  codec->ffmpeg_id == CODEC_ID_MPEG1VIDEO ||
00715                                  codec->ffmpeg_id == CODEC_ID_MPEG2VIDEO ||
00716                                  codec->ffmpeg_id == CODEC_ID_H263P || 
00717                                  codec->ffmpeg_id == CODEC_FLAG_H263P_SLICE_STRUCT))
00718                         {
00719                                 avcodec_thread_init(context, file->cpus);
00720                                 context->thread_count = file->cpus;
00721                         }
00722 
00723                         if(!codec->fix_bitrate)
00724                                 context->flags |= CODEC_FLAG_QSCALE;
00725 
00726                         if(codec->interlaced)
00727                         {
00728                                 context->flags |= CODEC_FLAG_INTERLACED_DCT;
00729                                 context->flags |= CODEC_FLAG_INTERLACED_ME;
00730                         }
00731 
00732 
00733 /*
00734  * printf("encode gop_size=%d fix_bitrate=%d quantizer=%d\n", 
00735  * codec->gop_size,
00736  * codec->fix_bitrate,
00737  * codec->quantizer);
00738  */
00739                         avcodec_open(context, codec->encoder[current_field]);
00740 
00741                         avcodec_get_frame_defaults(&codec->picture[current_field]);
00742 
00743                 }
00744         }
00745 
00746 
00747         if(!codec->work_buffer)
00748         {
00749                 codec->buffer_size = width_i * height_i;
00750                 codec->work_buffer = malloc(codec->buffer_size);
00751         }
00752 
00753 
00754 
00755 // Encore section
00756         if(codec->use_encore)
00757         {
00758 // Encore section
00759                 ENC_FRAME encore_input;
00760                 ENC_RESULT encore_result;
00761 
00762 
00763 // Assume planes are contiguous.
00764 // Encode directly from function arguments
00765                 if(file->color_model == BC_YUV420P &&
00766                         width == width_i &&
00767                         height == height_i)
00768                 {
00769                         encore_input.image = row_pointers[0];
00770                 }
00771 // Convert to YUV420P
00772 // Encode from temporary.
00773                 else
00774                 {
00775                         if(!codec->temp_frame)
00776                         {
00777                                 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
00778                         }
00779 
00780                         cmodel_transfer(0, /* Leave NULL if non existent */
00781                                 row_pointers,
00782                                 codec->temp_frame, /* Leave NULL if non existent */
00783                                 codec->temp_frame + width_i * height_i,
00784                                 codec->temp_frame + width_i * height_i + width_i * height_i / 4,
00785                                 row_pointers[0], /* Leave NULL if non existent */
00786                                 row_pointers[1],
00787                                 row_pointers[2],
00788                                 0,        /* Dimensions to capture from input frame */
00789                                 0, 
00790                                 width, 
00791                                 height,
00792                                 0,       /* Dimensions to project on output frame */
00793                                 0, 
00794                                 width, 
00795                                 height,
00796                                 file->color_model, 
00797                                 BC_YUV420P,
00798                                 0,         /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
00799                                 width,       /* For planar use the luma rowspan */
00800                                 width_i);
00801 
00802 
00803                         encore_input.image = codec->temp_frame;
00804                 }
00805 
00806 
00807 
00808                 bzero(codec->work_buffer, codec->buffer_size);
00809                 encore_input.bitstream = codec->work_buffer;
00810                 encore_input.length = 0;
00811                 encore_input.quant = !codec->fix_bitrate ? codec->quantizer : 0;
00812 
00813                 if(codec->p_count == 0)
00814                 {
00815                         codec->p_count[current_field]++;
00816                 }
00817                 else
00818                 {
00819                         codec->p_count[current_field]++;
00820                         if(codec->p_count[current_field] >= codec->max_key_interval)
00821                                 codec->p_count[current_field] = 0;
00822                 }
00823 
00824 
00825                 encore(codec->encode_handle[current_field],     
00826                         0,      
00827                         &encore_input,
00828                         &encore_result);
00829 
00830                 bytes = encore_input.length;
00831                 is_keyframe = encore_result.isKeyFrame;
00832         }
00833         else
00834 // ffmpeg section
00835         {
00836                 AVCodecContext *context = codec->encoder_context[current_field];
00837                 AVFrame *picture = &codec->picture[current_field];
00838 
00839                 if(width_i == width && 
00840                         height_i == height && 
00841                         file->color_model == BC_YUV420P)
00842                 {
00843                         picture->data[0] = row_pointers[0];
00844                         picture->data[1] = row_pointers[1];
00845                         picture->data[2] = row_pointers[2];
00846                         picture->linesize[0] = width_i;
00847                         picture->linesize[1] = width_i / 2;
00848                         picture->linesize[2] = width_i / 2;
00849                 }
00850                 else
00851                 {
00852                         if(!codec->temp_frame)
00853                         {
00854                                 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
00855                         }
00856 
00857                         cmodel_transfer(0, /* Leave NULL if non existent */
00858                                 row_pointers,
00859                                 codec->temp_frame, /* Leave NULL if non existent */
00860                                 codec->temp_frame + width_i * height_i,
00861                                 codec->temp_frame + width_i * height_i + width_i * height_i / 4,
00862                                 row_pointers[0], /* Leave NULL if non existent */
00863                                 row_pointers[1],
00864                                 row_pointers[2],
00865                                 0,        /* Dimensions to capture from input frame */
00866                                 0, 
00867                                 width, 
00868                                 height,
00869                                 0,       /* Dimensions to project on output frame */
00870                                 0, 
00871                                 width, 
00872                                 height,
00873                                 file->color_model, 
00874                                 BC_YUV420P,
00875                                 0,         /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
00876                                 width,       /* For planar use the luma rowspan */
00877                                 width_i);
00878 
00879                         picture->data[0] = codec->temp_frame;
00880                         picture->data[1] = codec->temp_frame + width_i * height_i;
00881                         picture->data[2] = codec->temp_frame + width_i * height_i + width_i * height_i / 4;
00882                         picture->linesize[0] = width_i;
00883                         picture->linesize[1] = width_i / 2;
00884                         picture->linesize[2] = width_i / 2;
00885                 }
00886 
00887 
00888                 picture->pict_type = 0;
00889                 picture->quality = 0;
00890                 picture->pts = vtrack->current_position * quicktime_frame_rate_d(file, track);
00891                 picture->key_frame = 0;
00892                 bytes = avcodec_encode_video(context, 
00893                         codec->work_buffer, 
00894                 codec->buffer_size, 
00895                 picture);
00896                 is_keyframe = context->coded_frame && context->coded_frame->key_frame;
00897 /*
00898  * printf("encode current_position=%d is_keyframe=%d\n", 
00899  * vtrack->current_position,
00900  * is_keyframe);
00901  */
00902 
00903                 if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
00904                         !strcmp(((quicktime_codec_t*)vtrack->codec)->fourcc, QUICKTIME_MP4V))
00905                 {
00906                         unsigned char temp[1024];
00907                         unsigned char *ptr = temp;
00908                         for(i = 0; i < bytes - 4; i++)
00909                         {
00910                                 if(!(codec->work_buffer[i] == 0x00 &&
00911                                         codec->work_buffer[i + 1] == 0x00 &&
00912                                         codec->work_buffer[i + 2] == 0x01 &&
00913                                         codec->work_buffer[i + 3] == 0xb3))
00914                                 {
00915                                         *ptr++ = codec->work_buffer[i];
00916                                 }
00917                                 else
00918                                         break;
00919                         }
00920                         quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0],
00921                                 temp, 
00922                                 ptr - temp);
00923                         trak->mdia.minf.stbl.stsd.table[0].version = 0;
00924                 }
00925         }
00926 
00927 
00928 
00929 
00930 
00931 
00932         pthread_mutex_unlock(&ffmpeg_lock);
00933         quicktime_write_chunk_header(file, trak, &chunk_atom);
00934         result = !quicktime_write_data(file, 
00935                 codec->work_buffer, 
00936                 bytes);
00937         quicktime_write_chunk_footer(file, 
00938                 trak,
00939                 vtrack->current_chunk,
00940                 &chunk_atom, 
00941                 1);
00942         if(is_keyframe || vtrack->current_position == 0)
00943                 quicktime_insert_keyframe(file, 
00944                         vtrack->current_position, 
00945                         track);
00946 
00947         vtrack->current_chunk++;
00948         return result;
00949 }
00950 
00951 
00952 
00953 
00954 
00955 
00956 static void flush(quicktime_t *file, int track)
00957 {
00958         quicktime_video_map_t *track_map = &(file->vtracks[track]);
00959         quicktime_trak_t *trak = track_map->track;
00960         quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
00961 
00962 // Create header
00963         if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
00964                 !strcmp(((quicktime_codec_t*)track_map->codec)->fourcc, QUICKTIME_MP4V))
00965         {
00966                 int width = trak->tkhd.track_width;
00967                 int height = trak->tkhd.track_height;
00968                 int width_i = quicktime_quantize16(width);
00969                 int height_i = quicktime_quantize16(height);
00970 
00971                 unsigned char temp[1024];
00972                 int size = write_mp4v_header(temp,
00973                         width_i,
00974                         height_i,
00975                         quicktime_frame_rate(file, track));
00976                 quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0],
00977                         temp, 
00978                         size);
00979         }
00980 
00981 // Create udta
00982         file->moov.udta.require = strdup("QuickTime 6.0 or greater");
00983         file->moov.udta.require_len = strlen(file->moov.udta.require);
00984 }
00985 
00986 
00987 
00988 
00989 
00990 
00991 
00992 
00993 static int set_parameter(quicktime_t *file, 
00994                 int track, 
00995                 char *key, 
00996                 void *value)
00997 {
00998         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
00999         char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
01000 
01001         if(quicktime_match_32(compressor, QUICKTIME_DIVX) ||
01002                 quicktime_match_32(compressor, QUICKTIME_MP42) ||
01003                 quicktime_match_32(compressor, QUICKTIME_MPG4) ||
01004                 quicktime_match_32(compressor, QUICKTIME_DX50) ||
01005                 quicktime_match_32(compressor, QUICKTIME_HV60))
01006         {
01007                 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
01008 
01009                 if(!strcasecmp(key, "divx_bitrate"))
01010                         codec->bitrate = *(int*)value;
01011                 else
01012                 if(!strcasecmp(key, "divx_rc_period"))
01013                         codec->rc_period = *(int*)value;
01014                 else
01015                 if(!strcasecmp(key, "divx_rc_reaction_ratio"))
01016                         codec->rc_reaction_ratio = *(int*)value;
01017                 else
01018                 if(!strcasecmp(key, "divx_rc_reaction_period"))
01019                         codec->rc_reaction_period = *(int*)value;
01020                 else
01021                 if(!strcasecmp(key, "divx_max_key_interval"))
01022                         codec->max_key_interval = *(int*)value;
01023                 else
01024                 if(!strcasecmp(key, "divx_max_quantizer"))
01025                         codec->max_quantizer = *(int*)value;
01026                 else
01027                 if(!strcasecmp(key, "divx_min_quantizer"))
01028                         codec->min_quantizer = *(int*)value;
01029                 else
01030                 if(!strcasecmp(key, "divx_quantizer"))
01031                         codec->quantizer = *(int*)value;
01032                 else
01033                 if(!strcasecmp(key, "divx_quality"))
01034                         codec->quality = *(int*)value;
01035                 else
01036                 if(!strcasecmp(key, "divx_fix_bitrate"))
01037                         codec->fix_bitrate = *(int*)value;
01038                 else
01039                 if(!strcasecmp(key, "divx_use_deblocking"))
01040                         codec->use_deblocking = *(int*)value;
01041         }
01042         else
01043         if(quicktime_match_32(compressor, QUICKTIME_DIV3) ||
01044                 quicktime_match_32(compressor, QUICKTIME_MP4V))
01045         {
01046                 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
01047                 if(!strcasecmp(key, "ffmpeg_bitrate"))
01048                         codec->bitrate = *(int*)value;
01049                 else
01050                 if(!strcasecmp(key, "ffmpeg_bitrate_tolerance"))
01051                         codec->bitrate_tolerance = *(int*)value;
01052                 else
01053                 if(!strcasecmp(key, "ffmpeg_interlaced"))
01054                         codec->interlaced = *(int*)value;
01055                 else
01056                 if(!strcasecmp(key, "ffmpeg_gop_size"))
01057                         codec->gop_size = *(int*)value;
01058                 else
01059                 if(!strcasecmp(key, "ffmpeg_quantizer"))
01060                         codec->quantizer = *(int*)value;
01061                 else
01062                 if(!strcasecmp(key, "ffmpeg_fix_bitrate"))
01063                         codec->fix_bitrate = *(int*)value;
01064         }
01065         return 0;
01066 }
01067 
01068 
01069 
01070 static int delete_codec(quicktime_video_map_t *vtrack)
01071 {
01072         quicktime_mpeg4_codec_t *codec;
01073         int i;
01074 
01075 
01076         codec = ((quicktime_codec_t*)vtrack->codec)->priv;
01077         for(i = 0; i < codec->total_fields; i++)
01078         {
01079                 if(codec->encode_initialized[i])
01080                 {
01081                         pthread_mutex_lock(&ffmpeg_lock);
01082                         if(codec->use_encore)
01083                         {
01084                                 encore(codec->encode_handle[i],
01085                                         ENC_OPT_RELEASE,
01086                                         0,
01087                                         0);
01088                         }
01089                         else
01090                         {
01091                         avcodec_close(codec->encoder_context[i]);
01092                                 free(codec->encoder_context[i]);
01093                         }
01094                         pthread_mutex_unlock(&ffmpeg_lock);
01095                 }
01096         }
01097 
01098 
01099         if(codec->temp_frame) free(codec->temp_frame);
01100         if(codec->work_buffer) free(codec->work_buffer);
01101         if(codec->decoder) quicktime_delete_ffmpeg(codec->decoder);
01102 
01103         free(codec);
01104         return 0;
01105 }
01106 
01107 
01108 
01109 
01110 static quicktime_mpeg4_codec_t* init_common(quicktime_video_map_t *vtrack, 
01111         char *compressor,
01112         char *title,
01113         char *description)
01114 {
01115         quicktime_codec_t *codec_base = (quicktime_codec_t*)vtrack->codec;
01116         quicktime_mpeg4_codec_t *codec;
01117 
01118         codec_base->priv = calloc(1, sizeof(quicktime_mpeg4_codec_t));
01119         codec_base->delete_vcodec = delete_codec;
01120         codec_base->decode_video = decode;
01121         codec_base->encode_video = encode;
01122         codec_base->flush = flush;
01123         codec_base->reads_colormodel = reads_colormodel;
01124         codec_base->writes_colormodel = writes_colormodel;
01125         codec_base->set_parameter = set_parameter;
01126         codec_base->fourcc = compressor;
01127         codec_base->title = title;
01128         codec_base->desc = description;
01129 
01130         codec = (quicktime_mpeg4_codec_t*)codec_base->priv;
01131 
01132 
01133 
01134 // Set defaults
01135         codec->bitrate = 1000000;
01136         codec->rc_period = 50;
01137         codec->rc_reaction_ratio = 45;
01138         codec->rc_reaction_period = 10;
01139         codec->max_key_interval = 45;
01140         codec->max_quantizer = 31;
01141         codec->min_quantizer = 1;
01142         codec->quantizer = 10;
01143         codec->quality = 5;
01144         codec->fix_bitrate = 1;
01145         codec->total_fields = 1;
01146 
01147 
01148 
01149         return codec;
01150 }
01151 
01152 
01153 
01154 
01155 // Mike Rowe Soft MPEG-4
01156 void quicktime_init_codec_div3(quicktime_video_map_t *vtrack)
01157 {
01158         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01159                 QUICKTIME_DIV3,
01160                 "DIVX",
01161                 "Mike Row Soft MPEG4 Version 3");
01162         result->ffmpeg_id = CODEC_ID_MSMPEG4V3;
01163 }
01164 
01165 void quicktime_init_codec_div5(quicktime_video_map_t *vtrack)
01166 {
01167         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01168                 QUICKTIME_DX50,
01169                 "DIVX",
01170                 "Mike Row Soft MPEG4 Version 5");
01171         result->ffmpeg_id = CODEC_ID_MPEG4;
01172 }
01173 
01174 // Mike Rowe Soft MPEG-4
01175 void quicktime_init_codec_div3lower(quicktime_video_map_t *vtrack)
01176 {
01177         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01178                 QUICKTIME_DIV3_LOWER,
01179                 "DIVX",
01180                 "Mike Row Soft MPEG4 Version 3");
01181         result->ffmpeg_id = CODEC_ID_MSMPEG4V3;
01182 }
01183 
01184 void quicktime_init_codec_div3v2(quicktime_video_map_t *vtrack)
01185 {
01186         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01187                 QUICKTIME_MP42,
01188                 "MP42",
01189                 "Mike Row Soft MPEG4 Version 2");
01190         result->ffmpeg_id = CODEC_ID_MSMPEG4V2;
01191 }
01192 
01193 // Generic MPEG-4
01194 void quicktime_init_codec_divx(quicktime_video_map_t *vtrack)
01195 {
01196         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01197                 QUICKTIME_DIVX,
01198                 "MPEG-4",
01199                 "Generic MPEG Four");
01200         result->ffmpeg_id = CODEC_ID_MPEG4;
01201         result->use_encore = 1;
01202 }
01203 
01204 void quicktime_init_codec_mpg4(quicktime_video_map_t *vtrack)
01205 {
01206         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01207                 QUICKTIME_MPG4,
01208                 "MPEG-4",
01209                 "FFMPEG (msmpeg4)");
01210         result->ffmpeg_id = CODEC_ID_MSMPEG4V1;
01211 }
01212 
01213 void quicktime_init_codec_dx50(quicktime_video_map_t *vtrack)
01214 {
01215         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01216                 QUICKTIME_DX50,
01217                 "MPEG-4",
01218                 "FFMPEG (mpeg4)");
01219         result->ffmpeg_id = CODEC_ID_MPEG4;
01220 }
01221 
01222 // Generic MPEG-4
01223 void quicktime_init_codec_mp4v(quicktime_video_map_t *vtrack)
01224 {
01225         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01226                 QUICKTIME_MP4V,
01227                 "MPEG4",
01228                 "Generic MPEG Four");
01229         result->ffmpeg_id = CODEC_ID_MPEG4;
01230 //      result->use_encore = 1;
01231 }
01232 
01233 
01234 // Mormon MPEG-4
01235 void quicktime_init_codec_svq1(quicktime_video_map_t *vtrack)
01236 {
01237         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01238                 QUICKTIME_SVQ1,
01239                 "Sorenson Version 1",
01240                 "From the chearch of codecs of yesterday's sights");
01241         result->ffmpeg_id = CODEC_ID_SVQ1;
01242 }
01243 
01244 void quicktime_init_codec_svq3(quicktime_video_map_t *vtrack)
01245 {
01246         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01247                 QUICKTIME_SVQ3,
01248                 "Sorenson Version 3",
01249                 "From the chearch of codecs of yesterday's sights");
01250         result->ffmpeg_id = CODEC_ID_SVQ3;
01251 }
01252 
01253 void quicktime_init_codec_h263(quicktime_video_map_t *vtrack)
01254 {
01255     quicktime_mpeg4_codec_t *result = init_common(vtrack,
01256         QUICKTIME_H263,
01257         "H.263",
01258         "H.263");
01259     result->ffmpeg_id = CODEC_ID_H263;
01260 }
01261 
01262 void quicktime_init_codec_xvid(quicktime_video_map_t *vtrack)
01263 {
01264     quicktime_mpeg4_codec_t *result = init_common(vtrack,
01265         QUICKTIME_XVID,
01266         "XVID",
01267         "FFmpeg MPEG-4");
01268     result->ffmpeg_id = CODEC_ID_MPEG4;
01269 }
01270 
01271 // field based MPEG-4
01272 void quicktime_init_codec_hv60(quicktime_video_map_t *vtrack)
01273 {
01274         quicktime_mpeg4_codec_t *result = init_common(vtrack, 
01275                 QUICKTIME_HV60,
01276                 "Dual MPEG-4",
01277                 "MPEG 4 with alternating streams every other frame.  (Not standardized)");
01278         result->total_fields = 2;
01279         result->ffmpeg_id = CODEC_ID_MPEG4;
01280 }
01281 
01282 
01283 
01284 
01285 
01286