quicktime/qtffmpeg.c

   1 #include "colormodels.h"
   2 #include "funcprotos.h"
   3 #include <pthread.h>
   4 #include "quicktime.h"
   5 #include "qtffmpeg.h"
   6 #include "qtprivate.h"
   7
   8 // FFMPEG front end for quicktime.
   9
  10
  11
  12
  13
  14
  15
  16
  17 int ffmpeg_initialized = 0;
  18 pthread_mutex_t ffmpeg_lock = PTHREAD_MUTEX_INITIALIZER;
  19
  20
  21
  22
  23
  24
  25 quicktime_ffmpeg_t* quicktime_new_ffmpeg(int cpus,
  26         int fields,
  27         int ffmpeg_id,
  28         int w,
  29         int h,
  30         quicktime_stsd_table_t *stsd_table)
  31 {
  32         quicktime_ffmpeg_t *ptr = calloc(1, sizeof(quicktime_ffmpeg_t));
  33         quicktime_esds_t *esds = &stsd_table->esds;
  34         quicktime_avcc_t *avcc = &stsd_table->avcc;
  35         int i;
  36
  37         ptr->fields = fields;
  38         ptr->width = w;
  39         ptr->height = h;
  40         ptr->ffmpeg_id = ffmpeg_id;
  41         if(ffmpeg_id == CODEC_ID_SVQ1)
  42         {
  43                 ptr->width_i = quicktime_quantize32(ptr->width);
  44                 ptr->height_i = quicktime_quantize32(ptr->height);
  45         }
  46         else
  47         {
  48                 ptr->width_i = quicktime_quantize16(ptr->width);
  49                 ptr->height_i = quicktime_quantize16(ptr->height);
  50         }
  51
  52         pthread_mutex_lock(&ffmpeg_lock);
  53         if(!ffmpeg_initialized)
  54         {
  55                 ffmpeg_initialized = 1;
  56                 avcodec_init();
  57                 avcodec_register_all();
  58         }
  59
  60         for(i = 0; i < fields; i++)
  61         {
  62                 ptr->decoder[i] = avcodec_find_decoder(ptr->ffmpeg_id);
  63                 if(!ptr->decoder[i])
  64                 {
  65                         printf("quicktime_new_ffmpeg: avcodec_find_decoder returned NULL.\n");
  66                         quicktime_delete_ffmpeg(ptr);
  67                         return 0;
  68                 }
  69                 ptr->decoder_context[i] = avcodec_alloc_context();
  70                 ptr->decoder_context[i]->width = w;
  71                 ptr->decoder_context[i]->height = h;
  72                 if(esds->mpeg4_header && esds->mpeg4_header_size)
  73                 {
  74                         ptr->decoder_context[i]->extradata = esds->mpeg4_header;
  75                         ptr->decoder_context[i]->extradata_size = esds->mpeg4_header_size;
  76                 }
  77                 if(avcc->data && avcc->data_size)
  78                 {
  79                         ptr->decoder_context[i]->extradata = avcc->data;
  80                         ptr->decoder_context[i]->extradata_size = avcc->data_size;
  81                 }
  82                 if(cpus > 1)
  83                 {
  84                         avcodec_thread_init(ptr->decoder_context[i], cpus);
  85                         ptr->decoder_context[i]->thread_count = cpus;
  86                 }
  87                 if(avcodec_open(ptr->decoder_context[i],
  88                         ptr->decoder[i]) < 0)
  89                 {
  90                         printf("quicktime_new_ffmpeg: avcodec_open failed.\n");
  91                         quicktime_delete_ffmpeg(ptr);
  92                 }
  93         }
  94         pthread_mutex_unlock(&ffmpeg_lock);
  95
  96         return ptr;
  97 }
  98
  99
 100
 101 void quicktime_delete_ffmpeg(quicktime_ffmpeg_t *ptr)
 102 {
 103         int i;
 104         if(ptr)
 105         {
 106                 pthread_mutex_lock(&ffmpeg_lock);
 107                 for(i = 0; i < ptr->fields; i++)
 108                 {
 109                         if(ptr->decoder_context[i])
 110                         {
 111                         avcodec_close(ptr->decoder_context[i]);
 112                                 free(ptr->decoder_context[i]);
 113                         }
 114                 }
 115                 pthread_mutex_unlock(&ffmpeg_lock);
 116
 117
 118
 119                 if(ptr->temp_frame) free(ptr->temp_frame);
 120                 if(ptr->work_buffer) free(ptr->work_buffer);
 121
 122
 123                 free(ptr);
 124         }
 125 }
 126
 127
 128 static int decode_wrapper(quicktime_t *file,
 129         quicktime_video_map_t *vtrack,
 130         quicktime_ffmpeg_t *ffmpeg,
 131         int frame_number,
 132         int current_field,
 133         int track,
 134         int drop_it)
 135 {
 136         int got_picture = 0;
 137         int result = 0;
 138         int bytes = 0;
 139         int header_bytes = 0;
 140         char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
 141         quicktime_trak_t *trak = vtrack->track;
 142         quicktime_stsd_table_t *stsd_table = &trak->mdia.minf.stbl.stsd.table[0];
 143
 144         quicktime_set_video_position(file, frame_number, track);
 145
 146         bytes = quicktime_frame_size(file, frame_number, track);
 147         if(frame_number == 0)
 148         {
 149                 header_bytes = stsd_table->esds.mpeg4_header_size;
 150         }
 151
 152         if(!ffmpeg->work_buffer || ffmpeg->buffer_size < bytes + header_bytes)
 153         {
 154                 if(ffmpeg->work_buffer) free(ffmpeg->work_buffer);
 155                 ffmpeg->buffer_size = bytes + header_bytes;
 156                 ffmpeg->work_buffer = calloc(1, ffmpeg->buffer_size + 100);
 157         }
 158
 159         if(header_bytes)
 160                 memcpy(ffmpeg->work_buffer, stsd_table->esds.mpeg4_header, header_bytes);
 161
 162         if(!quicktime_read_data(file,
 163                 ffmpeg->work_buffer + header_bytes,
 164                 bytes))
 165                 result = -1;
 166
 167
 168         if(!result)
 169         {
 170
 171
 172 // No way to determine if there was an error based on nonzero status.
 173 // Need to test row pointers to determine if an error occurred.
 174                 if(drop_it)
 175                         ffmpeg->decoder_context[current_field]->skip_frame = AVDISCARD_NONREF;
 176                 else
 177                         ffmpeg->decoder_context[current_field]->skip_frame = AVDISCARD_DEFAULT;
 178                 result = avcodec_decode_video(ffmpeg->decoder_context[current_field],
 179                         &ffmpeg->picture[current_field],
 180                         &got_picture,
 181                         ffmpeg->work_buffer,
 182                         bytes + header_bytes);
 183
 184
 185
 186                 if(ffmpeg->picture[current_field].data[0])
 187                 {
 188                         result = 0;
 189                 }
 190                 else
 191                 {
 192 // ffmpeg can't recover if the first frame errored out, like in a direct copy
 193 // sequence.
 194                         result = 1;
 195                 }
 196
 197 #ifdef ARCH_X86
 198                 asm("emms");
 199 #endif
 200         }
 201
 202         return result;
 203 }
 204
 205
 206
 207 int quicktime_ffmpeg_decode(quicktime_ffmpeg_t *ffmpeg,
 208         quicktime_t *file,
 209         unsigned char **row_pointers,
 210         int track)
 211 {
 212         quicktime_video_map_t *vtrack = &(file->vtracks[track]);
 213         quicktime_trak_t *trak = vtrack->track;
 214         int current_field = vtrack->current_position % ffmpeg->fields;
 215         int input_cmodel;
 216         int result = 0;
 217         int seeking_done = 0;
 218         int i;
 219
 220         pthread_mutex_lock(&ffmpeg_lock);
 221
 222 // Handle seeking
 223         if(quicktime_has_keyframes(file, track) &&
 224                 vtrack->current_position != ffmpeg->last_frame[current_field] + ffmpeg->fields)
 225         {
 226                 int frame1;
 227                 int frame2 = vtrack->current_position;
 228                 int current_frame = frame2;
 229                 int do_i_frame = 1;
 230
 231 // Get first keyframe of same field
 232                 do
 233                 {
 234                         frame1 = quicktime_get_keyframe_before(file,
 235                                 current_frame--,
 236                                 track);
 237                 }while(frame1 > 0 && (frame1 % ffmpeg->fields) != current_field);
 238
 239 // Keyframe is before last decoded frame and current frame is after last decoded
 240 // frame, so instead of rerendering from the last keyframe we can rerender from
 241 // the last decoded frame.
 242                 if(frame1 < ffmpeg->last_frame[current_field] &&
 243                         frame2 > ffmpeg->last_frame[current_field])
 244                 {
 245                         frame1 = ffmpeg->last_frame[current_field] + ffmpeg->fields;
 246                         do_i_frame = 0;
 247                 }
 248
 249                 while(frame1 <= frame2)
 250                 {
 251                         result = decode_wrapper(file,
 252                                 vtrack,
 253                                 ffmpeg,
 254                                 frame1,
 255                                 current_field,
 256                                 track,
 257                                 (frame1 < frame2));
 258
 259
 260 // May need to do the first I frame twice.
 261                         if(do_i_frame)
 262                         {
 263                                 result = decode_wrapper(file,
 264                                         vtrack,
 265                                         ffmpeg,
 266                                         frame1,
 267                                         current_field,
 268                                         track,
 269                                         0);
 270                                 do_i_frame = 0;
 271                         }
 272                         frame1 += ffmpeg->fields;
 273                 }
 274
 275                 vtrack->current_position = frame2;
 276                 seeking_done = 1;
 277         }
 278
 279         if(!seeking_done)
 280         {
 281                 result = decode_wrapper(file,
 282                         vtrack,
 283                         ffmpeg,
 284                         vtrack->current_position,
 285                         current_field,
 286                         track,
 287                         0);
 288         }
 289
 290         pthread_mutex_unlock(&ffmpeg_lock);
 291
 292
 293         ffmpeg->last_frame[current_field] = vtrack->current_position;
 294
 295         switch(ffmpeg->decoder_context[current_field]->pix_fmt)
 296         {
 297                 case PIX_FMT_YUV420P:
 298                         input_cmodel = BC_YUV420P;
 299                         break;
 300                 case PIX_FMT_YUV422:
 301                         input_cmodel = BC_YUV422;
 302                         break;
 303                 case PIX_FMT_YUV422P:
 304                         input_cmodel = BC_YUV422P;
 305                         break;
 306                 case PIX_FMT_YUV410P:
 307                         input_cmodel = BC_YUV9P;
 308                         break;
 309                 default:
 310                         fprintf(stderr,
 311                                 "quicktime_ffmpeg_decode: unrecognized color model %d\n",
 312                                 ffmpeg->decoder_context[current_field]->pix_fmt);
 313                         input_cmodel = BC_YUV420P;
 314                         break;
 315         }
 316
 317         if(ffmpeg->picture[current_field].data[0])
 318         {
 319                 unsigned char **input_rows;
 320
 321                 input_rows =
 322                         malloc(sizeof(unsigned char*) *
 323                         ffmpeg->decoder_context[current_field]->height);
 324
 325
 326                 for(i = 0; i < ffmpeg->decoder_context[current_field]->height; i++)
 327                         input_rows[i] = ffmpeg->picture[current_field].data[0] +
 328                                 i *
 329                                 ffmpeg->decoder_context[current_field]->width *
 330                                 cmodel_calculate_pixelsize(input_cmodel);
 331
 332
 333                 cmodel_transfer(row_pointers, /* Leave NULL if non existent */
 334                         input_rows,
 335                         row_pointers[0], /* Leave NULL if non existent */
 336                         row_pointers[1],
 337                         row_pointers[2],
 338                         ffmpeg->picture[current_field].data[0], /* Leave NULL if non existent */
 339                         ffmpeg->picture[current_field].data[1],
 340                         ffmpeg->picture[current_field].data[2],
 341                         file->in_x,        /* Dimensions to capture from input frame */
 342                         file->in_y,
 343                         file->in_w,
 344                         file->in_h,
 345                         0,       /* Dimensions to project on output frame */
 346                         0,
 347                         file->out_w,
 348                         file->out_h,
 349                         input_cmodel,
 350                         file->color_model,
 351                         0,         /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
 352                         ffmpeg->picture[current_field].linesize[0],       /* For planar use the luma rowspan */
 353                         ffmpeg->width);
 354                 free(input_rows);
 355         }
 356
 357
 358         return result;
 359 }
 360
 361
 362
 363
 364
 365