Cinelerra: hvirtual/libmpeg3/libmpeg3.c Source File

00001 #include "libmpeg3.h"
00002 #include "mpeg3private.h"
00003 #include "mpeg3protos.h"
00004 
00005 #include <errno.h>
00006 #include <fcntl.h>
00007 #include <stdlib.h>
00008 #include <string.h>
00009 
00010 
00011 int mpeg3_major()
00012 {
00013         return MPEG3_MAJOR;
00014 }
00015 
00016 int mpeg3_minor()
00017 {
00018         return MPEG3_MINOR;
00019 }
00020 
00021 int mpeg3_release()
00022 {
00023         return MPEG3_RELEASE;
00024 }
00025 
00026 
00027 
00028 mpeg3_t* mpeg3_new(char *path)
00029 {
00030         int i;
00031         mpeg3_t *file = calloc(1, sizeof(mpeg3_t));
00032         file->cpus = 1;
00033         file->fs = mpeg3_new_fs(path);
00034 // Late compilers don't produce usable code.
00035         file->demuxer = mpeg3_new_demuxer(file, 0, 0, -1);
00036         file->seekable = 1;
00037         file->index_bytes = 0x300000;
00038         file->subtitle_track = -1;
00039         return file;
00040 }
00041 
00042 mpeg3_index_t* mpeg3_new_index()
00043 {
00044         mpeg3_index_t *index = calloc(1, sizeof(mpeg3_index_t));
00045         index->index_zoom = 1;
00046         return index;
00047 }
00048 
00049 void mpeg3_delete_index(mpeg3_index_t *index)
00050 {
00051         int i;
00052         for(i = 0;i < index->index_channels; i++)
00053                 free(index->index_data[i]);
00054         free(index->index_data);
00055         free(index);
00056 }
00057 
00058 int mpeg3_delete(mpeg3_t *file)
00059 {
00060         int i;
00061 const int debug = 0;
00062 
00063 if(debug) printf("mpeg3_delete 1\n");
00064         for(i = 0; i < file->total_vstreams; i++)
00065                 mpeg3_delete_vtrack(file, file->vtrack[i]);
00066 if(debug) printf("mpeg3_delete 2\n");
00067 
00068         for(i = 0; i < file->total_astreams; i++)
00069                 mpeg3_delete_atrack(file, file->atrack[i]);
00070 
00071         for(i = 0; i < file->total_sstreams; i++)
00072                 mpeg3_delete_strack(file->strack[i]);
00073         
00074 
00075 if(debug) printf("mpeg3_delete 3\n");
00076         mpeg3_delete_fs(file->fs);
00077         mpeg3_delete_demuxer(file->demuxer);
00078 
00079 if(debug) printf("mpeg3_delete 4\n");
00080         if(file->frame_offsets)
00081         {
00082                 for(i = 0; i < file->total_vstreams; i++)
00083                 {
00084                         free(file->frame_offsets[i]);
00085                         free(file->keyframe_numbers[i]);
00086                 }
00087 
00088 if(debug) printf("mpeg3_delete 5\n");
00089                 free(file->frame_offsets);
00090                 free(file->keyframe_numbers);
00091                 free(file->total_frame_offsets);
00092                 free(file->total_keyframe_numbers);
00093         }
00094 
00095 if(debug) printf("mpeg3_delete 6\n");
00096         if(file->sample_offsets)
00097         {
00098                 for(i = 0; i < file->total_astreams; i++)
00099                         free(file->sample_offsets[i]);
00100 
00101                 free(file->sample_offsets);
00102                 free(file->total_sample_offsets);
00103         }
00104 
00105 if(debug) printf("mpeg3_delete 7\n");
00106 
00107         if(file->channel_counts)
00108                 free(file->channel_counts);
00109 
00110         if(file->audio_eof)
00111                 free(file->audio_eof);
00112 
00113 if(debug) printf("mpeg3_delete 8\n");
00114         if(file->indexes)
00115         {
00116                 for(i = 0; i < file->total_indexes; i++)
00117                         mpeg3_delete_index(file->indexes[i]);
00118 if(debug) printf("mpeg3_delete 9\n");
00119                         
00120                 free(file->indexes);
00121         }
00122 
00123 if(debug) printf("mpeg3_delete 10\n");
00124         free(file);
00125 if(debug) printf("mpeg3_delete 11\n");
00126         return 0;
00127 }
00128 
00129 int mpeg3_check_sig(char *path)
00130 {
00131         mpeg3_fs_t *fs;
00132         u_int32_t bits, bits2;
00133         char *ext;
00134         int result = 0;
00135 
00136         fs = mpeg3_new_fs(path);
00137         if(mpeg3io_open_file(fs))
00138         {
00139 /* File not found */
00140                 return 0;
00141         }
00142 
00143         bits = mpeg3io_read_int32(fs);
00144         bits2 = mpeg3io_read_int32(fs);
00145         ext = strrchr(path, '.');
00146 /* Test header */
00147         if(bits == MPEG3_TOC_PREFIX)
00148         {
00149                 result = 1;
00150         }
00151         else
00152         if(((bits2 >> 24) & 0xff) == MPEG3_SYNC_BYTE &&
00153                 ext &&
00154                 !strncasecmp(ext, ".m2ts", 5))
00155         {
00156                 result = 1;
00157         }
00158         else
00159         if((((bits >> 24) & 0xff) == MPEG3_SYNC_BYTE) ||
00160                 (bits == MPEG3_PACK_START_CODE) ||
00161                 ((bits & 0xfff00000) == 0xfff00000) ||
00162                 ((bits & 0xffff0000) == 0xffe30000) ||
00163                 (bits == MPEG3_SEQUENCE_START_CODE) ||
00164                 (bits == MPEG3_PICTURE_START_CODE) ||
00165                 (((bits & 0xffff0000) >> 16) == MPEG3_AC3_START_CODE) ||
00166                 ((bits >> 8) == MPEG3_ID3_PREFIX) ||
00167                 (bits == MPEG3_RIFF_CODE) ||
00168         (bits == MPEG3_IFO_PREFIX))
00169         {
00170                 result = 1;
00171 
00172                 if(ext)
00173                 {
00174 /* Test file extension. */
00175                         if(strncasecmp(ext, ".ifo", 4) && 
00176                 strncasecmp(ext, ".mp2", 4) && 
00177                                 strncasecmp(ext, ".mp3", 4) &&
00178                                 strncasecmp(ext, ".m1v", 4) &&
00179                                 strncasecmp(ext, ".m2v", 4) &&
00180                                 strncasecmp(ext, ".m2s", 4) &&
00181                                 strncasecmp(ext, ".mpg", 4) &&
00182                                 strncasecmp(ext, ".vob", 4) &&
00183                                 strncasecmp(ext, ".mpeg", 4) &&
00184                                 strncasecmp(ext, ".m2t", 4) &&
00185                                 strncasecmp(ext, ".ac3", 4))
00186                                 result = 0;
00187                 }
00188         }
00189 
00190         mpeg3io_close_file(fs);
00191         mpeg3_delete_fs(fs);
00192         return result;
00193 }
00194 
00195 
00196 
00197 
00198 
00199 
00200 
00201 
00202 
00203 
00204 static int is_toc(uint32_t bits)
00205 {
00206         return (bits == MPEG3_TOC_PREFIX);
00207 }
00208 
00209 
00210 static int is_ifo(uint32_t bits)
00211 {
00212         return (bits == MPEG3_IFO_PREFIX);
00213 }
00214 
00215 static int is_transport(uint32_t bits)
00216 {
00217         return (((bits >> 24) & 0xff) == MPEG3_SYNC_BYTE);
00218 }
00219 
00220 static int is_bd(uint32_t bits1, uint32_t bits2)
00221 {
00222         return (((bits2 >> 24) & 0xff) == MPEG3_SYNC_BYTE);
00223 }
00224 
00225 static int is_program(uint32_t bits)
00226 {
00227         return (bits == MPEG3_PACK_START_CODE);
00228 }
00229 
00230 static int is_mpeg_audio(uint32_t bits)
00231 {
00232         return (bits & 0xfff00000) == 0xfff00000 ||
00233                 (bits & 0xffff0000) == 0xffe30000 ||
00234                 ((bits >> 8) == MPEG3_ID3_PREFIX) ||
00235                 (bits == MPEG3_RIFF_CODE);
00236 }
00237 
00238 static int is_mpeg_video(uint32_t bits)
00239 {
00240         return (bits == MPEG3_SEQUENCE_START_CODE ||
00241                         bits == MPEG3_PICTURE_START_CODE);
00242 }
00243 
00244 static int is_ac3(uint32_t bits)
00245 {
00246         return (((bits & 0xffff0000) >> 16) == MPEG3_AC3_START_CODE);
00247 }
00248 
00249 static int calculate_packet_size(int is_transport,
00250         int is_program,
00251         int is_audio,
00252         int is_video,
00253         int is_bd)
00254 {
00255         if(is_transport)
00256         {
00257                 if(is_bd)
00258                         return MPEG3_BD_PACKET_SIZE;
00259                 else
00260                         return MPEG3_TS_PACKET_SIZE;
00261         }
00262         else
00263         if(is_program)
00264                 return 0;
00265         else
00266         if(is_audio)
00267                 return MPEG3_DVD_PACKET_SIZE;
00268         else
00269         if(is_video)
00270                 return MPEG3_DVD_PACKET_SIZE;
00271 }
00272 
00273 
00274 
00275 int mpeg3_get_file_type(mpeg3_t *file, 
00276         mpeg3_t *old_file,
00277         int *toc_atracks,
00278         int *toc_vtracks)
00279 {
00280         uint32_t bits = mpeg3io_read_int32(file->fs);
00281         uint32_t bits2 = mpeg3io_read_int32(file->fs);
00282         int result = 0;
00283 
00284         if(old_file) file->is_bd = old_file->is_bd;
00285 
00286 /* TOC  */
00287         if(is_toc(bits))   
00288         {
00289 /* Table of contents for another title set */
00290                 if(!old_file)
00291                 {
00292                         if(toc_atracks && toc_vtracks)
00293                         {
00294                                 if((result = mpeg3_read_toc(file, toc_atracks, toc_vtracks)))
00295                                 {
00296                                         mpeg3io_close_file(file->fs);
00297                                         return result;
00298                                 }
00299                         }
00300                         else
00301                         {
00302                                 mpeg3io_close_file(file->fs);
00303                                 return 1;
00304                         }
00305                 }
00306                 mpeg3io_close_file(file->fs);
00307         }
00308         else
00309 /* IFO file */
00310     if(is_ifo(bits))
00311     {
00312         if(!old_file)
00313                 {
00314                         file->is_program_stream = 1;
00315                         if(mpeg3_read_ifo(file, 0))
00316                 {
00317                                 mpeg3io_close_file(file->fs);
00318                                 return 1;
00319                 }
00320                 }
00321                 file->is_ifo_file = 1;
00322                 mpeg3io_close_file(file->fs);
00323     }
00324     else
00325         if(is_bd(bits, bits2))
00326         {
00327                 file->is_bd = 1;
00328                 file->is_transport_stream = 1;
00329         }
00330         else
00331         if(is_transport(bits))
00332         {
00333 /* Transport stream */
00334                 file->is_transport_stream = 1;
00335         }
00336         else
00337         if(is_program(bits))
00338         {
00339 /* Program stream */
00340 /* Determine packet size empirically */
00341                 file->is_program_stream = 1;
00342         }
00343         else
00344         if(is_mpeg_audio(bits))
00345         {
00346 /* MPEG Audio only */
00347                 file->is_audio_stream = 1;
00348         }
00349         else
00350         if(is_mpeg_video(bits))
00351         {
00352 /* Video only */
00353                 file->is_video_stream = 1;
00354         }
00355         else
00356         if(is_ac3(bits))
00357         {
00358 /* AC3 Audio only */
00359                 file->is_audio_stream = 1;
00360         }
00361         else
00362         {
00363                 fprintf(stderr, "mpeg3_get_file_type: not a readable stream.\n");
00364                 return 1;
00365         }
00366 
00367 /*
00368  * printf("mpeg3_get_file_type 2 %p %d %d %d %d\n", 
00369  * old_file, 
00370  * file->is_transport_stream, 
00371  * file->is_program_stream, 
00372  * file->is_video_stream, 
00373  * file->is_audio_stream);
00374  */
00375 
00376 
00377         file->packet_size = calculate_packet_size(file->is_transport_stream,
00378                 file->is_program_stream,
00379                 file->is_audio_stream,
00380                 file->is_video_stream,
00381                 file->is_bd);
00382 
00383         return 0;
00384 }
00385 
00386 
00387 static void copy_subtitles(mpeg3_t *file, mpeg3_t *old_file)
00388 {
00389         int i, j;
00390         file->total_sstreams = old_file->total_sstreams;
00391         for(i = 0; i < file->total_sstreams; i++)
00392         {
00393                 file->strack[i] = mpeg3_new_strack(old_file->strack[i]->id);
00394                 mpeg3_copy_strack(file->strack[i], old_file->strack[i]);
00395         }
00396 
00397         memcpy(file->palette, old_file->palette, 16 * 4);
00398         file->have_palette = old_file->have_palette;
00399 }
00400 
00401 
00402 mpeg3_t* mpeg3_open_copy(char *path, mpeg3_t *old_file, int *error_return)
00403 {
00404         mpeg3_t *file = 0;
00405         int i, done;
00406         int result = 0;
00407 /* The table of contents may have fewer tracks than are in the demuxer */
00408 /* This limits the track count */
00409         int toc_atracks = 0x7fffffff;
00410         int toc_vtracks = 0x7fffffff;
00411 
00412 
00413 /* Initialize the file structure */
00414         file = mpeg3_new(path);
00415 
00416 
00417 /* Need to perform authentication before reading a single byte. */
00418         if(mpeg3io_open_file(file->fs))
00419         {
00420                 mpeg3_delete(file);
00421                 return 0;
00422         }
00423 
00424 
00425 
00426 
00427 
00428 /* =============================== Create the title objects ========================= */
00429         if((*error_return = mpeg3_get_file_type(file, 
00430                 old_file,
00431                 &toc_atracks, 
00432                 &toc_vtracks)))
00433         {
00434                 mpeg3_delete(file);
00435                 return 0;
00436         }
00437 
00438 
00439 
00440 
00441 
00442 
00443 
00444 
00445 
00446 
00447 
00448 /* Create titles */
00449 /* Copy data from an old file */
00450         if(old_file && mpeg3_get_demuxer(old_file))
00451         {
00452                 mpeg3demux_copy_titles(file->demuxer, mpeg3_get_demuxer(old_file));
00453                 copy_subtitles(file, old_file);
00454 
00455                 file->is_transport_stream = old_file->is_transport_stream;
00456                 file->is_program_stream = old_file->is_program_stream;
00457                 file->is_bd = old_file->is_bd;
00458                 file->source_date = old_file->source_date;
00459         }
00460         else
00461 /* Start from scratch */
00462         if(!file->demuxer->total_titles)
00463         {
00464                 mpeg3_create_title(file->demuxer, 0);
00465         }
00466 
00467 
00468 
00469 
00470 
00471 
00472 
00473 
00474 
00475 
00476 
00477 
00478 
00479 /* Generate tracks */
00480         if(file->is_transport_stream || file->is_program_stream)
00481         {
00482 /* Create video tracks */
00483                 for(i = 0; 
00484                         i < MPEG3_MAX_STREAMS && file->total_vstreams < toc_vtracks; 
00485                         i++)
00486                 {
00487                         if(file->demuxer->vstream_table[i])
00488                         {
00489                                 file->vtrack[file->total_vstreams] = 
00490                                         mpeg3_new_vtrack(file, 
00491                                                 i, 
00492                                                 file->demuxer, 
00493                                                 file->total_vstreams);
00494                                 if(file->vtrack[file->total_vstreams]) 
00495                                         file->total_vstreams++;
00496 
00497                         }
00498                 }
00499 
00500 /* Create audio tracks */
00501                 for(i = 0; i < MPEG3_MAX_STREAMS && file->total_astreams < toc_atracks; i++)
00502                 {
00503                         if(file->demuxer->astream_table[i])
00504                         {
00505                                 file->atrack[file->total_astreams] = mpeg3_new_atrack(file, 
00506                                         i, 
00507                                         file->demuxer->astream_table[i], 
00508                                         file->demuxer,
00509                                         file->total_astreams);
00510                                 if(file->atrack[file->total_astreams]) file->total_astreams++;
00511                         }
00512                 }
00513         }
00514         else
00515         if(file->is_video_stream)
00516         {
00517 /* Create video tracks */
00518                 file->vtrack[0] = mpeg3_new_vtrack(file, 
00519                         -1, 
00520                         file->demuxer, 
00521                         0);
00522                 if(file->vtrack[0]) file->total_vstreams++;
00523         }
00524         else
00525         if(file->is_audio_stream)
00526         {
00527 /* Create audio tracks */
00528 
00529                 file->atrack[0] = mpeg3_new_atrack(file, 
00530                         -1, 
00531                         AUDIO_UNKNOWN, 
00532                         file->demuxer,
00533                         0);
00534                 if(file->atrack[0]) file->total_astreams++;
00535         }
00536 
00537 
00538 
00539 
00540 
00541         mpeg3io_close_file(file->fs);
00542 
00543         return file;
00544 }
00545 
00546 mpeg3_t* mpeg3_open(char *path, int *error_return)
00547 {
00548         return mpeg3_open_copy(path, 0, error_return);
00549 }
00550 
00551 int mpeg3_close(mpeg3_t *file)
00552 {
00553 /* File is closed in the same procedure it is opened in. */
00554         mpeg3_delete(file);
00555         return 0;
00556 }
00557 
00558 int mpeg3_set_cpus(mpeg3_t *file, int cpus)
00559 {
00560         int i;
00561         file->cpus = cpus;
00562         for(i = 0; i < file->total_vstreams; i++)
00563                 mpeg3video_set_cpus(file->vtrack[i]->video, cpus);
00564         return 0;
00565 }
00566 
00567 int mpeg3_has_audio(mpeg3_t *file)
00568 {
00569         return file->total_astreams > 0;
00570 }
00571 
00572 int mpeg3_total_astreams(mpeg3_t *file)
00573 {
00574         return file->total_astreams;
00575 }
00576 
00577 int mpeg3_audio_channels(mpeg3_t *file,
00578                 int stream)
00579 {
00580         if(file->total_astreams)
00581                 return file->atrack[stream]->channels;
00582         return -1;
00583 }
00584 
00585 int mpeg3_sample_rate(mpeg3_t *file,
00586                 int stream)
00587 {
00588         if(file->total_astreams)
00589                 return file->atrack[stream]->sample_rate;
00590         return -1;
00591 }
00592 
00593 long mpeg3_get_sample(mpeg3_t *file,
00594                 int stream)
00595 {
00596         if(file->total_astreams)
00597                 return file->atrack[stream]->current_position;
00598         return -1;
00599 }
00600 
00601 int mpeg3_set_sample(mpeg3_t *file, 
00602                 long sample,
00603                 int stream)
00604 {
00605         if(file->total_astreams)
00606         {
00607 //printf(__FUNCTION__ " 1 %d %d\n", file->atrack[stream]->current_position, sample);
00608                 file->atrack[stream]->current_position = sample;
00609                 mpeg3audio_seek_sample(file->atrack[stream]->audio, sample);
00610                 return 0;
00611         }
00612         return -1;
00613 }
00614 
00615 long mpeg3_audio_samples(mpeg3_t *file,
00616                 int stream)
00617 {
00618         if(file->total_astreams)
00619                 return file->atrack[stream]->total_samples;
00620         return -1;
00621 }
00622 
00623 char* mpeg3_audio_format(mpeg3_t *file, int stream)
00624 {
00625         if(stream < file->total_astreams)
00626         {
00627                 switch(file->atrack[stream]->format)
00628                 {
00629                         case AUDIO_UNKNOWN: return "Unknown"; break;
00630                         case AUDIO_MPEG:    return "MPEG"; break;
00631                         case AUDIO_AC3:     return "AC3"; break;
00632                         case AUDIO_PCM:     return "PCM"; break;
00633                         case AUDIO_AAC:     return "AAC"; break;
00634                         case AUDIO_JESUS:   return "Vorbis"; break;
00635                 }
00636         }
00637         return "";
00638 }
00639 
00640 int mpeg3_has_video(mpeg3_t *file)
00641 {
00642         return file->total_vstreams > 0;
00643 }
00644 
00645 int mpeg3_total_vstreams(mpeg3_t *file)
00646 {
00647         return file->total_vstreams;
00648 }
00649 
00650 int mpeg3_video_width(mpeg3_t *file,
00651                 int stream)
00652 {
00653         if(file->total_vstreams)
00654                 return file->vtrack[stream]->width;
00655         return -1;
00656 }
00657 
00658 int mpeg3_video_height(mpeg3_t *file,
00659                 int stream)
00660 {
00661         if(file->total_vstreams)
00662                 return file->vtrack[stream]->height;
00663         return -1;
00664 }
00665 
00666 float mpeg3_aspect_ratio(mpeg3_t *file, int stream)
00667 {
00668         if(file->total_vstreams)
00669                 return file->vtrack[stream]->aspect_ratio;
00670         return 0;
00671 }
00672 
00673 double mpeg3_frame_rate(mpeg3_t *file,
00674                 int stream)
00675 {
00676         if(file->total_vstreams)
00677                 return file->vtrack[stream]->frame_rate;
00678         return -1;
00679 }
00680 
00681 long mpeg3_video_frames(mpeg3_t *file,
00682                 int stream)
00683 {
00684         if(file->total_vstreams)
00685                 return file->vtrack[stream]->total_frames;
00686         return -1;
00687 }
00688 
00689 long mpeg3_get_frame(mpeg3_t *file,
00690                 int stream)
00691 {
00692         if(file->total_vstreams)
00693                 return file->vtrack[stream]->current_position;
00694         return -1;
00695 }
00696 
00697 int mpeg3_set_frame(mpeg3_t *file, 
00698                 long frame,
00699                 int stream)
00700 {
00701         if(file->total_vstreams)
00702         {
00703                 file->vtrack[stream]->current_position = frame;
00704                 mpeg3video_seek_frame(file->vtrack[stream]->video, frame);
00705                 return 0;
00706         }
00707         return -1;
00708 }
00709 
00710 int mpeg3_seek_byte(mpeg3_t *file, int64_t byte)
00711 {
00712         int i;
00713 
00714 //      file->percentage_pts = -1;
00715         for(i = 0; i < file->total_vstreams; i++)
00716         {
00717                 file->vtrack[i]->current_position = 0;
00718                 mpeg3video_seek_byte(file->vtrack[i]->video, byte);
00719         }
00720 
00721         for(i = 0; i < file->total_astreams; i++)
00722         {
00723                 file->atrack[i]->current_position = 0;
00724                 mpeg3audio_seek_byte(file->atrack[i]->audio, byte);
00725         }
00726 
00727         return 0;
00728 }
00729 
00730 /*
00731  * double mpeg3_get_percentage_pts(mpeg3_t *file)
00732  * {
00733  *      return file->percentage_pts;
00734  * }
00735  * 
00736  * void mpeg3_set_percentage_pts(mpeg3_t *file, double pts)
00737  * {
00738  * }
00739  */
00740 
00741 
00742 int mpeg3_previous_frame(mpeg3_t *file, int stream)
00743 {
00744         file->last_type_read = 2;
00745         file->last_stream_read = stream;
00746 
00747         if(file->total_vstreams)
00748                 return mpeg3video_previous_frame(file->vtrack[stream]->video);
00749 
00750         return 0;
00751 }
00752 
00753 int64_t mpeg3_tell_byte(mpeg3_t *file)
00754 {
00755         int64_t result = 0;
00756         if(file->last_type_read == 1)
00757         {
00758                 result = mpeg3demux_tell_byte(file->atrack[file->last_stream_read]->demuxer);
00759         }
00760 
00761         if(file->last_type_read == 2)
00762         {
00763                 result = mpeg3demux_tell_byte(file->vtrack[file->last_stream_read]->demuxer);
00764         }
00765         return result;
00766 }
00767 
00768 int64_t mpeg3_get_bytes(mpeg3_t *file)
00769 {
00770         return mpeg3demux_movie_size(file->demuxer);
00771 }
00772 
00773 double mpeg3_get_time(mpeg3_t *file)
00774 {
00775         double atime = 0, vtime = 0;
00776 
00777         if(file->is_transport_stream || file->is_program_stream)
00778         {
00779 /* Timecode only available in transport stream */
00780                 if(file->last_type_read == 1)
00781                 {
00782                         atime = mpeg3demux_get_time(file->atrack[file->last_stream_read]->demuxer);
00783                 }
00784                 else
00785                 if(file->last_type_read == 2)
00786                 {
00787                         vtime = mpeg3demux_get_time(file->vtrack[file->last_stream_read]->demuxer);
00788                 }
00789         }
00790         else
00791         {
00792 /* Use percentage and total time */
00793                 if(file->total_astreams)
00794                 {
00795                         atime = mpeg3demux_tell_byte(file->atrack[0]->demuxer) * 
00796                                                 mpeg3_audio_samples(file, 0) / 
00797                                                 mpeg3_sample_rate(file, 0) /
00798                                                 mpeg3_get_bytes(file);
00799                 }
00800 
00801                 if(file->total_vstreams)
00802                 {
00803                         vtime = mpeg3demux_tell_byte(file->vtrack[0]->demuxer) *
00804                                                 mpeg3_video_frames(file, 0) / 
00805                                                 mpeg3_frame_rate(file, 0) /
00806                                                 mpeg3_get_bytes(file);
00807                 }
00808         }
00809 
00810         return MAX(atime, vtime);
00811 }
00812 
00813 int mpeg3_end_of_audio(mpeg3_t *file, int stream)
00814 {
00815         int result = 0;
00816         if(!file->atrack[stream]->channels) return 1;
00817         result = mpeg3demux_eof(file->atrack[stream]->demuxer);
00818         return result;
00819 }
00820 
00821 int mpeg3_end_of_video(mpeg3_t *file, int stream)
00822 {
00823         int result = 0;
00824         result = mpeg3demux_eof(file->vtrack[stream]->demuxer);
00825         return result;
00826 }
00827 
00828 
00829 int mpeg3_drop_frames(mpeg3_t *file, long frames, int stream)
00830 {
00831         int result = -1;
00832 
00833         if(file->total_vstreams)
00834         {
00835                 result = mpeg3video_drop_frames(file->vtrack[stream]->video, 
00836                                                 frames,
00837                                                 0);
00838                 if(frames > 0) file->vtrack[stream]->current_position += frames;
00839                 file->last_type_read = 2;
00840                 file->last_stream_read = stream;
00841         }
00842         return result;
00843 }
00844 
00845 int mpeg3_colormodel(mpeg3_t *file, int stream)
00846 {
00847         if(file->total_vstreams)
00848         {
00849                 return mpeg3video_colormodel(file->vtrack[stream]->video);
00850         }
00851         return 0;
00852 }
00853 
00854 int mpeg3_set_rowspan(mpeg3_t *file, int bytes, int stream)
00855 {
00856         if(file->total_vstreams)
00857         {
00858                 file->vtrack[stream]->video->row_span = bytes;
00859         }
00860         return 0;
00861 }
00862 
00863 
00864 int mpeg3_read_frame(mpeg3_t *file, 
00865                 unsigned char **output_rows, 
00866                 int in_x, 
00867                 int in_y, 
00868                 int in_w, 
00869                 int in_h, 
00870                 int out_w, 
00871                 int out_h, 
00872                 int color_model,
00873                 int stream)
00874 {
00875         int result = -1;
00876 //printf("mpeg3_read_frame 1 %d\n", file->vtrack[stream]->current_position);
00877 
00878         if(file->total_vstreams)
00879         {
00880                 result = mpeg3video_read_frame(file->vtrack[stream]->video, 
00881                                         output_rows,
00882                                         in_x, 
00883                                         in_y, 
00884                                         in_w, 
00885                                         in_h, 
00886                                         out_w,
00887                                         out_h,
00888                                         color_model);
00889 //printf(__FUNCTION__ " 2\n");
00890                 file->last_type_read = 2;
00891                 file->last_stream_read = stream;
00892                 file->vtrack[stream]->current_position++;
00893         }
00894 
00895 //printf("mpeg3_read_frame 2 %d\n", file->vtrack[stream]->current_position);
00896         return result;
00897 }
00898 
00899 int mpeg3_read_yuvframe(mpeg3_t *file,
00900                 char *y_output,
00901                 char *u_output,
00902                 char *v_output,
00903                 int in_x, 
00904                 int in_y,
00905                 int in_w,
00906                 int in_h,
00907                 int stream)
00908 {
00909         int result = -1;
00910 
00911 //printf("mpeg3_read_yuvframe 1\n");
00912         if(file->total_vstreams)
00913         {
00914                 result = mpeg3video_read_yuvframe(file->vtrack[stream]->video, 
00915                                         y_output,
00916                                         u_output,
00917                                         v_output,
00918                                         in_x,
00919                                         in_y,
00920                                         in_w,
00921                                         in_h);
00922                 file->last_type_read = 2;
00923                 file->last_stream_read = stream;
00924                 file->vtrack[stream]->current_position++;
00925         }
00926 //printf("mpeg3_read_yuvframe 100\n");
00927         return result;
00928 }
00929 
00930 int mpeg3_read_yuvframe_ptr(mpeg3_t *file,
00931                 char **y_output,
00932                 char **u_output,
00933                 char **v_output,
00934                 int stream)
00935 {
00936         int result = -1;
00937 
00938         if(file->total_vstreams)
00939         {
00940                 result = mpeg3video_read_yuvframe_ptr(file->vtrack[stream]->video, 
00941                                         y_output,
00942                                         u_output,
00943                                         v_output);
00944                 file->last_type_read = 2;
00945                 file->last_stream_read = stream;
00946                 file->vtrack[stream]->current_position++;
00947         }
00948         return result;
00949 }
00950 
00951 int mpeg3_read_audio(mpeg3_t *file, 
00952                 float *output_f, 
00953                 short *output_i, 
00954                 int channel, 
00955                 long samples,
00956                 int stream)
00957 {
00958         int result = -1;
00959 
00960         if(file->total_astreams)
00961         {
00962                 result = mpeg3audio_decode_audio(file->atrack[stream]->audio, 
00963                                         output_f, 
00964                                         output_i, 
00965                                         channel, 
00966                                         samples);
00967                 file->last_type_read = 1;
00968                 file->last_stream_read = stream;
00969                 file->atrack[stream]->current_position += samples;
00970         }
00971 
00972         return result;
00973 }
00974 
00975 int mpeg3_reread_audio(mpeg3_t *file, 
00976                 float *output_f, 
00977                 short *output_i, 
00978                 int channel, 
00979                 long samples,
00980                 int stream)
00981 {
00982         if(file->total_astreams)
00983         {
00984                 mpeg3_set_sample(file, 
00985                         file->atrack[stream]->current_position - samples,
00986                         stream);
00987                 file->last_type_read = 1;
00988                 file->last_stream_read = stream;
00989                 return mpeg3_read_audio(file, 
00990                         output_f, 
00991                         output_i, 
00992                         channel, 
00993                         samples,
00994                         stream);
00995         }
00996         return -1;
00997 }
00998 
00999 int mpeg3_read_audio_chunk(mpeg3_t *file, 
01000                 unsigned char *output, 
01001                 long *size, 
01002                 long max_size,
01003                 int stream)
01004 {
01005         int result = 0;
01006         if(file->total_astreams)
01007         {
01008                 result = mpeg3audio_read_raw(file->atrack[stream]->audio, 
01009                         output, 
01010                         size, 
01011                         max_size);
01012                 file->last_type_read = 1;
01013                 file->last_stream_read = stream;
01014         }
01015         return result;
01016 }
01017 
01018 int mpeg3_read_video_chunk(mpeg3_t *file, 
01019                 unsigned char *output, 
01020                 long *size, 
01021                 long max_size,
01022                 int stream)
01023 {
01024         int result = 0;
01025         if(file->total_vstreams)
01026         {
01027                 result = mpeg3video_read_raw(file->vtrack[stream]->video, 
01028                         output, 
01029                         size, 
01030                         max_size);
01031                 file->last_type_read = 2;
01032                 file->last_stream_read = stream;
01033         }
01034         return result;
01035 }
01036 
01037 
01038 
01039 int64_t mpeg3_memory_usage(mpeg3_t *file)
01040 {
01041         int i;
01042         int64_t result = 0;
01043         for(i = 0; i < file->total_vstreams; i++)
01044         {
01045                 result += mpeg3_cache_usage(file->vtrack[i]->frame_cache);
01046         }
01047         return result;
01048 }
01049