quicktime/qtmp3.c

   1 #include "funcprotos.h"
   2
   3 #ifdef MMX
   4 #define MMX_TEMP
   5 #undef MMX
   6 #endif
   7 #include <lame/lame.h>
   8
   9 #ifdef MMX_TEMP
  10 #define MMX
  11 #endif
  12
  13
  14 #include "mpeg3private.h"
  15 #include "mpeg3protos.h"
  16 #include "quicktime.h"
  17 #include "qtmp3.h"
  18
  19 #define CLAMP(x, y, z) ((x) = ((x) <  (y) ? (y) : ((x) > (z) ? (z) : (x))))
  20
  21 #define OUTPUT_ALLOCATION 0x100000
  22
  23 //static FILE *test = 0;
  24
  25 typedef struct
  26 {
  27 // mp3 decoder
  28         mpeg3_layer_t *mp3;
  29 // Can't use same structure for header testing
  30         mpeg3_layer_t *mp3_header;
  31         unsigned char *packet_buffer;
  32         int packet_allocated;
  33
  34
  35 // Number of first sample in output relative to file
  36         int64_t output_position;
  37 // Number of samples in output buffer
  38         long output_size;
  39 // Number of samples allocated in output buffer
  40         long output_allocated;
  41 // Current reading position in file
  42         int64_t chunk;
  43         int decode_initialized;
  44         float **output;
  45
  46
  47
  48 // mp3 encoder
  49         lame_global_flags *lame_global;
  50 // This calculates the number of samples per chunk
  51         mpeg3_layer_t *encoded_header;
  52         int encode_initialized;
  53         float **input;
  54         int input_size;
  55         int input_allocated;
  56         int bitrate;
  57         unsigned char *encoder_output;
  58         int encoder_output_size;
  59         int encoder_output_allocated;
  60 } quicktime_mp3_codec_t;
  61
  62
  63
  64
  65
  66 static int delete_codec(quicktime_audio_map_t *atrack)
  67 {
  68         quicktime_mp3_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
  69         if(codec->mp3) mpeg3_delete_layer(codec->mp3);
  70         if(codec->mp3_header)  mpeg3_delete_layer(codec->mp3_header);
  71         if(codec->packet_buffer) free(codec->packet_buffer);
  72         if(codec->output)
  73         {
  74                 int i;
  75                 for(i = 0; i < atrack->channels; i++)
  76                         free(codec->output[i]);
  77                 free(codec->output);
  78         }
  79
  80         if(codec->lame_global)
  81         {
  82                 lame_close(codec->lame_global);
  83         }
  84
  85         if(codec->input)
  86         {
  87                 int i;
  88                 for(i = 0; i < atrack->channels; i++)
  89                 {
  90                         free(codec->input[i]);
  91                 }
  92                 free(codec->input);
  93         }
  94
  95         if(codec->encoder_output)
  96                 free(codec->encoder_output);
  97
  98         if(codec->encoded_header)
  99                 mpeg3_delete_layer(codec->encoded_header);
 100
 101         free(codec);
 102
 103         return 0;
 104 }
 105
 106 static int chunk_len(quicktime_t *file,
 107         quicktime_mp3_codec_t *codec,
 108         int64_t offset,
 109         int64_t next_chunk)
 110 {
 111         int result = 0;
 112         unsigned char header[4];
 113         int accum = 0;
 114
 115         while(offset < next_chunk)
 116         {
 117                 quicktime_set_position(file, offset);
 118                 result = !quicktime_read_data(file, (unsigned char*)&header, 4);
 119
 120                 if(result)
 121                 {
 122                         return accum;
 123                 }
 124
 125 // Decode size of mp3 frame
 126                 result = mpeg3_layer_header(codec->mp3_header,
 127                         header);
 128
 129 // Invalid header
 130                 if(!result)
 131                         return accum;
 132                 else
 133 // Valid header
 134                 {
 135                         accum += result;
 136                         offset += result;
 137                         quicktime_set_position(file, offset + result);
 138                 }
 139         }
 140         return accum;
 141 }
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152 static int decode(quicktime_t *file,
 153                                         int16_t *output_i,
 154                                         float *output_f,
 155                                         long samples,
 156                                         int track,
 157                                         int channel)
 158 {
 159         int result = 0;
 160         quicktime_audio_map_t *track_map = &(file->atracks[track]);
 161         quicktime_mp3_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
 162         quicktime_trak_t *trak = track_map->track;
 163         long current_position = track_map->current_position;
 164         long end_position = current_position + samples;
 165         float *pcm;
 166         int i, j, k;
 167         int64_t offset1;
 168         int64_t offset2;
 169         int chunk_size;
 170         int new_size;
 171         int frame_size;
 172         int try = 0;
 173         float **temp_output;
 174
 175         if(samples > OUTPUT_ALLOCATION)
 176                 printf("decode: can't read more than %d samples at a time.\n", OUTPUT_ALLOCATION);
 177
 178
 179 //printf("decode 1\n");
 180         if(output_i) bzero(output_i, sizeof(int16_t) * samples);
 181         if(output_f) bzero(output_f, sizeof(float) * samples);
 182
 183         temp_output = malloc(sizeof(float*) * track_map->channels);
 184
 185 // Seeked outside output buffer's range or not initialized: restart
 186         if(current_position < codec->output_position ||
 187                 current_position > codec->output_position + codec->output_size ||
 188                 !codec->decode_initialized)
 189         {
 190                 quicktime_chunk_of_sample(&codec->output_position,
 191                         &codec->chunk,
 192                         trak,
 193                         current_position);
 194
 195 // We know the first mp3 packet in the chunk has a pcm_offset from the encoding.
 196                 codec->output_size = 0;
 197 //printf("decode 1 %lld %d\n", codec->output_position, quicktime_chunk_samples(trak, codec->chunk));
 198                 codec->output_position = quicktime_sample_of_chunk(trak, codec->chunk);
 199 //printf("decode 2 %lld\n", codec->output_position);
 200
 201 // Initialize and load initial buffer for decoding
 202                 if(!codec->decode_initialized)
 203                 {
 204                         int i;
 205                         codec->decode_initialized = 1;
 206                         codec->output = malloc(sizeof(float*) * track_map->channels);
 207                         for(i = 0; i < track_map->channels; i++)
 208                         {
 209                                 codec->output[i] = malloc(sizeof(float) * OUTPUT_ALLOCATION);
 210                         }
 211                         codec->output_allocated = OUTPUT_ALLOCATION;
 212                         codec->mp3 = mpeg3_new_layer();
 213                         codec->mp3_header = mpeg3_new_layer();
 214                 }
 215         }
 216
 217 // Decode chunks until output is big enough
 218         while(codec->output_position + codec->output_size <
 219                 current_position + samples &&
 220                 try < 6)
 221         {
 222 // Decode a chunk
 223                 offset1 = quicktime_chunk_to_offset(file, trak, codec->chunk);
 224                 offset2 = quicktime_chunk_to_offset(file, trak, codec->chunk + 1);
 225
 226                 if(offset2 == offset1) break;
 227
 228                 chunk_size = chunk_len(file, codec, offset1, offset2);
 229
 230                 if(codec->packet_allocated < chunk_size &&
 231                         codec->packet_buffer)
 232                 {
 233                         free(codec->packet_buffer);
 234                         codec->packet_buffer = 0;
 235                 }
 236
 237                 if(!codec->packet_buffer)
 238                 {
 239                         codec->packet_buffer = calloc(1, chunk_size);
 240                         codec->packet_allocated = chunk_size;
 241                 }
 242
 243                 quicktime_set_position(file, offset1);
 244                 result = !quicktime_read_data(file, codec->packet_buffer, chunk_size);
 245                 if(result) break;
 246
 247                 for(i = 0; i < chunk_size; )
 248                 {
 249 // Allocate more output
 250                         new_size = codec->output_size + MAXFRAMESAMPLES;
 251                         if(new_size > codec->output_allocated)
 252                         {
 253                                 for(j = 0; j < track_map->channels; j++)
 254                                 {
 255                                         float *new_output = calloc(sizeof(float), new_size);
 256                                         memcpy(new_output,
 257                                                 codec->output[j],
 258                                                 sizeof(float) * codec->output_size);
 259                                         free(codec->output[j]);
 260                                         codec->output[j] = new_output;
 261                                 }
 262                                 codec->output_allocated = new_size;
 263                         }
 264
 265 // Decode a frame
 266                         for(j = 0; j < track_map->channels; j++)
 267                                 temp_output[j] = codec->output[j] + codec->output_size;
 268
 269                         frame_size = mpeg3_layer_header(codec->mp3,
 270                                 codec->packet_buffer + i);
 271
 272                         result = mpeg3audio_dolayer3(codec->mp3,
 273                                 codec->packet_buffer + i,
 274                                 frame_size,
 275                                 temp_output,
 276                                 1);
 277
 278
 279                         if(result)
 280                         {
 281                                 codec->output_size += result;
 282                                 result = 0;
 283                                 try = 0;
 284                         }
 285                         else
 286                         {
 287                                 try++;
 288                         }
 289
 290                         i += frame_size;
 291                 }
 292
 293                 codec->chunk++;
 294         }
 295
 296 // Transfer region of output to argument
 297         pcm = codec->output[channel];
 298         if(output_i)
 299         {
 300                 for(i = current_position - codec->output_position, j = 0;
 301                         j < samples && i < codec->output_size;
 302                         j++, i++)
 303                 {
 304                         int sample = pcm[i] * 32767;
 305                         CLAMP(sample, -32768, 32767);
 306                         output_i[j] = sample;
 307                 }
 308         }
 309         else
 310         if(output_f)
 311         {
 312                 for(i = current_position - codec->output_position, j = 0;
 313                         j < samples && i < codec->output_size;
 314                         j++, i++)
 315                 {
 316                         output_f[j] = pcm[i];
 317                 }
 318         }
 319
 320 // Delete excess output
 321         if(codec->output_size > OUTPUT_ALLOCATION)
 322         {
 323                 int diff = codec->output_size - OUTPUT_ALLOCATION;
 324                 for(k = 0; k < track_map->channels; k++)
 325                 {
 326                         pcm = codec->output[k];
 327                         for(i = 0, j = diff; j < codec->output_size; i++, j++)
 328                         {
 329                                 pcm[i] = pcm[j];
 330                         }
 331                 }
 332                 codec->output_size -= diff;
 333                 codec->output_position += diff;
 334         }
 335
 336         free(temp_output);
 337 //printf("decode 100\n");
 338         return 0;
 339 }
 340
 341
 342
 343
 344 static int allocate_output(quicktime_mp3_codec_t *codec,
 345         int samples)
 346 {
 347         int new_size = codec->encoder_output_size + samples * 4;
 348         if(codec->encoder_output_allocated < new_size)
 349         {
 350                 unsigned char *new_output = calloc(1, new_size);
 351
 352                 if(codec->encoder_output)
 353                 {
 354                         memcpy(new_output,
 355                                 codec->encoder_output,
 356                                 codec->encoder_output_size);
 357                         free(codec->encoder_output);
 358                 }
 359                 codec->encoder_output = new_output;
 360                 codec->encoder_output_allocated = new_size;
 361         }
 362
 363 }
 364
 365
 366
 367 // Empty the output buffer of frames
 368 static int write_frames(quicktime_t *file,
 369         quicktime_audio_map_t *track_map,
 370         quicktime_trak_t *trak,
 371         quicktime_mp3_codec_t *codec)
 372 {
 373         int result = 0;
 374         int i, j;
 375         int frames_end = 0;
 376         quicktime_atom_t chunk_atom;
 377
 378 // Write to chunks
 379         for(i = 0; i < codec->encoder_output_size - 4; )
 380         {
 381                 unsigned char *header = codec->encoder_output + i;
 382                 int frame_size = mpeg3_layer_header(codec->encoded_header, header);
 383
 384                 if(frame_size)
 385                 {
 386 // Frame is finished before end of buffer
 387                         if(i + frame_size <= codec->encoder_output_size)
 388                         {
 389 // Write the chunk
 390                                 int64_t offset;
 391                                 int frame_samples = mpeg3audio_dolayer3(codec->encoded_header,
 392                                         header,
 393                                         frame_size,
 394                                         0,
 395                                         0);
 396
 397                                 quicktime_write_chunk_header(file, trak, &chunk_atom);
 398                                 result = !quicktime_write_data(file, header, frame_size);
 399 // Knows not to save the chunksizes for audio
 400                                 quicktime_write_chunk_footer(file,
 401                                         trak,
 402                                         track_map->current_chunk,
 403                                         &chunk_atom,
 404                                         frame_samples);
 405
 406                                 track_map->current_chunk++;
 407                                 i += frame_size;
 408                                 frames_end = i;
 409                         }
 410                         else
 411 // Frame isn't finished before end of buffer.
 412                         {
 413                                 frames_end = i;
 414                                 break;
 415                         }
 416                 }
 417                 else
 418 // Not the start of a frame.  Skip it.
 419                 {
 420                         i++;
 421                         frames_end = i;
 422                 }
 423         }
 424
 425         if(frames_end > 0)
 426         {
 427                 for(i = frames_end, j = 0; i < codec->encoder_output_size; i++, j++)
 428                 {
 429                         codec->encoder_output[j] = codec->encoder_output[i];
 430                 }
 431                 codec->encoder_output_size -= frames_end;
 432         }
 433         return result;
 434 }
 435
 436
 437
 438
 439
 440
 441 static int encode(quicktime_t *file,
 442                                                         int16_t **input_i,
 443                                                         float **input_f,
 444                                                         int track,
 445                                                         long samples)
 446 {
 447         int result = 0;
 448         quicktime_audio_map_t *track_map = &(file->atracks[track]);
 449         quicktime_trak_t *trak = track_map->track;
 450         quicktime_mp3_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
 451         int new_size = codec->input_size + samples;
 452         int i, j;
 453         int frames_end = 0;
 454
 455         if(!codec->encode_initialized)
 456         {
 457                 codec->encode_initialized = 1;
 458                 codec->lame_global = lame_init();
 459                 lame_set_brate(codec->lame_global, codec->bitrate / 1000);
 460                 lame_set_quality(codec->lame_global, 0);
 461                 lame_set_in_samplerate(codec->lame_global,
 462                         trak->mdia.minf.stbl.stsd.table[0].sample_rate);
 463                 if((result = lame_init_params(codec->lame_global)) < 0)
 464                         printf("encode: lame_init_params returned %d\n", result);
 465                 codec->encoded_header = mpeg3_new_layer();
 466                 if(file->use_avi)
 467                         trak->mdia.minf.stbl.stsd.table[0].sample_size = 0;
 468         }
 469
 470
 471 // Stack input on end of buffer
 472         if(new_size > codec->input_allocated)
 473         {
 474                 float *new_input;
 475
 476                 if(!codec->input)
 477                         codec->input = calloc(sizeof(float*), track_map->channels);
 478
 479                 for(i = 0; i < track_map->channels; i++)
 480                 {
 481                         new_input = calloc(sizeof(float), new_size);
 482                         if(codec->input[i])
 483                         {
 484                                 memcpy(new_input, codec->input[i], sizeof(float) * codec->input_size);
 485                                 free(codec->input[i]);
 486                         }
 487                         codec->input[i] = new_input;
 488                 }
 489                 codec->input_allocated = new_size;
 490         }
 491
 492
 493 // Transfer to input buffers
 494         if(input_i)
 495         {
 496                 for(i = 0; i < track_map->channels; i++)
 497                 {
 498                         for(j = 0; j < samples; j++)
 499                                 codec->input[i][j] = input_i[i][j];
 500                 }
 501         }
 502         else
 503         if(input_f)
 504         {
 505                 for(i = 0; i < track_map->channels; i++)
 506                 {
 507                         for(j = 0; j < samples; j++)
 508                                 codec->input[i][j] = input_f[i][j] * 32767;
 509                 }
 510         }
 511
 512 // Encode
 513         allocate_output(codec, samples);
 514
 515         result = lame_encode_buffer_float(codec->lame_global,
 516                 codec->input[0],
 517                 (track_map->channels > 1) ? codec->input[1] : codec->input[0],
 518                 samples,
 519                 codec->encoder_output + codec->encoder_output_size,
 520                 codec->encoder_output_allocated - codec->encoder_output_size);
 521
 522         codec->encoder_output_size += result;
 523
 524         result = write_frames(file,
 525                 track_map,
 526                 trak,
 527                 codec);
 528
 529         return result;
 530 }
 531
 532
 533
 534 static int set_parameter(quicktime_t *file,
 535                 int track,
 536                 char *key,
 537                 void *value)
 538 {
 539         quicktime_audio_map_t *atrack = &(file->atracks[track]);
 540         quicktime_mp3_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
 541
 542         if(!strcasecmp(key, "mp3_bitrate"))
 543                 codec->bitrate = *(int*)value;
 544
 545         return 0;
 546 }
 547
 548
 549
 550 static void flush(quicktime_t *file, int track)
 551 {
 552         int result = 0;
 553         int64_t offset = quicktime_position(file);
 554         quicktime_audio_map_t *track_map = &(file->atracks[track]);
 555         quicktime_trak_t *trak = track_map->track;
 556         quicktime_mp3_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
 557
 558         if(codec->encode_initialized)
 559         {
 560                 result = lame_encode_flush(codec->lame_global,
 561                 codec->encoder_output + codec->encoder_output_size,
 562                         codec->encoder_output_allocated - codec->encoder_output_size);
 563                 codec->encoder_output_size += result;
 564                 result = write_frames(file,
 565                         track_map,
 566                         trak,
 567                         codec);
 568         }
 569 }
 570
 571
 572 void quicktime_init_codec_mp3(quicktime_audio_map_t *atrack)
 573 {
 574         quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
 575         quicktime_mp3_codec_t *codec;
 576
 577 /* Init public items */
 578         codec_base->priv = calloc(1, sizeof(quicktime_mp3_codec_t));
 579         codec_base->delete_acodec = delete_codec;
 580         codec_base->decode_audio = decode;
 581         codec_base->encode_audio = encode;
 582         codec_base->set_parameter = set_parameter;
 583         codec_base->flush = flush;
 584         codec_base->fourcc = QUICKTIME_MP3;
 585         codec_base->title = "MP3";
 586         codec_base->desc = "MP3 for video";
 587         codec_base->wav_id = 0x55;
 588
 589         codec = codec_base->priv;
 590         codec->bitrate = 256000;
 591 }
 592
 593
 594
 595