inptstrm.cpp

传输流分析

                                                                access_unit.first_frame_offset += (unsigned int)(secs_per_frame * CLOCKS);
                                        } else
                                                access_unit.first_frame_offset = 0;
                                }

                                *startup_delay=(PTS < *startup_delay ? PTS : *startup_delay);

                                make_timecode (DTS, &access_unit.DTS);
                                make_timecode (PTS, &access_unit.PTS);
                                if (!comp_timecode(&access_unit.PTS, &video_info->last_PTS))
                                        copy_timecode(&access_unit.PTS, &video_info->last_PTS);
                                decoding_order++;
                                group_order++;

                                if ((access_unit.type > 0) && (access_unit.type < 5))
                                        video_info->num_frames[access_unit.type-1]++;

                                video_info->num_pictures++;
                                break;

                        case SEQUENCE_END:
                                pict_offset = bitcount(&bs);
                                access_unit.length = (unsigned long) ceil((pict_offset - prev_offset) / 8.0);
                                if (fwrite (&access_unit, sizeof (Vaunit_struc), 1, info_file) != 1) {
                                        sprintf(tmpStr, "Error writing to temporary video file %s: %s.",
                                                video_units, strerrno());
                                        DisplayError(tmpStr);
                                        goto exit2;
                                }
                                video_info->avg_frames[access_unit.type-1]+= access_unit.length;
                                prev_offset = pict_offset;
                                video_info->num_seq_end++;
                                video_count++;
                                break;
                        }
                } else
                        break;
        } while (!end_bs(&bs));

        if (!AbortMPEG) {
                sprintf(tmpStr, "  Found %d picture headers, stream bit offset %.0f.",
                        video_info->num_pictures, prev_offset);
                DisplayInfo(tmpStr);

                video_info->stream_length = (unsigned long) ceil(prev_offset / 8.0);
                for (i=0; i<4; i++)
                        if (video_info->num_frames[i]!=0)
                                video_info->avg_frames[i] /= video_info->num_frames[i];

                if (secs_per_frame >0.) {
                        // set max computed bitrate to max over any one second
                        video_info->comp_max_bit_rate = (uint)ceil((double)max_bits_in_sec/400.);
                        // set avg computed bitrate to avg over any one second
                        video_info->comp_avg_bit_rate = (uint)ceil ((double)(video_info->stream_length)/
                                                        (double)(video_info->num_pictures)/secs_per_frame/1250.)*25;
                } else {
                        video_info->comp_max_bit_rate = 0;
                        video_info->comp_avg_bit_rate = 0;
                }
                exiterror = FALSE;
                *video_total = video_count;
        }

exit2:
        finish_getbits(&bs);
        fclose(info_file);
        if (exiterror)
                unlink(video_units);
        else
                output_info_video(video_info);
        return !exiterror;
}

/*************************************************************************
	Output_Info_Video
	gibt Ubersicht ueber gesammelte Informationen aus
 
	Prints information on video access units
*************************************************************************/

void output_info_video (
        Video_struc *video_info)
{
        char tmpStr[132];

        DisplayInfo("  Video stream information");
        sprintf(tmpStr, "    Stream length : %u",video_info->stream_length);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    Total time (seconds) : %u",(unsigned int)(get_timecode(&video_info->last_PTS) / CLOCKS));
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    Sequence start : %u",video_info->num_sequence);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    Sequence end : %u",video_info->num_seq_end);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    No. Pictures : %u",video_info->num_pictures);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    No. Groups : %u",video_info->num_groups);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    No. I Frames : %u avg. size %u bytes",
                video_info->num_frames[0],video_info->avg_frames[0]);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    No. P Frames : %u avg. size %u bytes",
                video_info->num_frames[1],video_info->avg_frames[1]);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    No. B Frames : %u avg. size %u bytes",
                video_info->num_frames[2],video_info->avg_frames[2]);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    No. D Frames : %u avg. size %u bytes",
                video_info->num_frames[3],video_info->avg_frames[3]);
        DisplayInfo(tmpStr);

        sprintf(tmpStr, "    Horizontal size : %u",video_info->horizontal_size);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    Vertical size : %u",video_info->vertical_size);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    Aspect ratio : %1.4f",ratio[video_info->aspect_ratio]);
        DisplayInfo(tmpStr);

        if (video_info->picture_rate == 0)
                DisplayInfo("    Picture rate : forbidden");
        else {
                if (video_info->picture_rate <9) {
                        sprintf(tmpStr, "    Picture rate : %2.3f frames/sec", picture_rates[video_info->picture_rate]);
                        switch (video_info->pulldown) {
                        case PULLDOWN_32:
                                strcat(tmpStr, ",  3:2 pulldown detected");
                                break;
                        case PULLDOWN_23:
                                strcat(tmpStr, ",  2:3 pulldown detected");
                                break;
                        }
                } else
                        sprintf(tmpStr, "    Picture rate : %x reserved",video_info->picture_rate);
                DisplayInfo(tmpStr);
        }

        if (video_info->bit_rate == 0x3ffff) {
                video_info->bit_rate = 0;
                DisplayInfo("    Bit rate : variable");
        } else

                if (video_info->bit_rate == 0)
                        DisplayInfo("    Bit rate : forbidden");
                else {
                        sprintf(tmpStr, "    Bit rate : %u bytes/sec (%u bits/sec)",
                                video_info->bit_rate*50,video_info->bit_rate*400);
                        DisplayInfo(tmpStr);
                }

        sprintf(tmpStr, "    Computed avg rate : %u bytes/sec (%u bits/sec)",
                video_info->comp_avg_bit_rate*50, video_info->comp_avg_bit_rate*400);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    Computed max rate : %u bytes/sec (%u bits/sec)",
                video_info->comp_max_bit_rate*50, video_info->comp_max_bit_rate*400);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    Vbv buffer size : %u bytes",video_info->vbv_buffer_size*2048);
        DisplayInfo(tmpStr);
        sprintf(tmpStr, "    CSPF : %u",video_info->CSPF);
        DisplayInfo(tmpStr);
        if ((mplex_type == MPEG_SVCD) && (video_info->picture_rate != 3) && (video_info->picture_rate != 4))
                DisplayInfo("  WARNING: SVCD frame rate should be either 25 fps or 29.97 fps");
}

/*************************************************************************
	Output_Info_Audio
	gibt gesammelte Informationen zu den Audio Access Units aus.
 
	Prints information on audio access units
*************************************************************************/

void output_info_audio (
        Audio_struc *audio_info)
{
        unsigned int layer;
        unsigned long bitrate;
        char tmpStr[132];

        if (audio_info->layer) {                                   /* MPEG */
                layer = 3 - audio_info->layer;
                bitrate = bitrate_index[layer][audio_info->bit_rate];

                DisplayInfo("  MPEG audio stream information");
                sprintf(tmpStr, "    Stream length : %u",audio_info->stream_length);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Syncwords : %u",audio_info->num_syncword);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Frames : %u size %u bytes",
                        audio_info->num_frames[0],audio_info->size_frames[0]);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Frames : %u size %u bytes",
                        audio_info->num_frames[1],audio_info->size_frames[1]);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Layer : %u",1+layer);
                DisplayInfo(tmpStr);

                if (audio_info->protection == 0)
                        DisplayInfo("    CRC checksums : yes");
                else
                        DisplayInfo("    CRC checksums : no");

                if (audio_info->bit_rate == 0)
                        DisplayInfo("    Bit rate : free");
                else
                        if (audio_info->bit_rate == 0xf)
                                DisplayInfo("    Bit rate : reserved");
                        else {
                                sprintf(tmpStr, "    Bit rate : %u bytes/sec (%u kbit/sec)",
                                        (uint)bitrate*125, (uint)bitrate);
                                DisplayInfo(tmpStr);
                        }

                if (audio_info->frequency == 3)
                        DisplayInfo("    Frequency : reserved");
                else {
                        sprintf(tmpStr, "    Frequency : %2.1f kHz",
                                frequency[audio_info->frequency]);
                        DisplayInfo(tmpStr);
                }

                sprintf(tmpStr, "    Mode : %u %s",
                        audio_info->mode, modetxt[audio_info->mode]);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Mode extension : %u",audio_info->mode_extension);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Copyright bit : %u %s",
                        audio_info->copyright,copyrighttxt[audio_info->copyright]);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Original/Copy : %u %s",
                        audio_info->original_copy,originaltxt[audio_info->original_copy]);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Emphasis : %u %s",
                        audio_info->emphasis,emphasistxt[audio_info->emphasis]);
                DisplayInfo(tmpStr);
        } else {               /* AC3 */
                bitrate = audio_info->bit_rate;

                DisplayInfo("  AC3 audio stream information");
                sprintf(tmpStr, "    Stream length : %u",audio_info->stream_length);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Syncwords : %u",audio_info->num_syncword);
                DisplayInfo(tmpStr);
                sprintf(tmpStr, "    Frames : %u size %u bytes",
                        audio_info->num_frames[0],audio_info->size_frames[0]);
                DisplayInfo(tmpStr);

                sprintf(tmpStr, "    Bit rate : %u bytes/sec (%u kbit/sec)",
                        (uint)bitrate*128, (uint)bitrate);
                DisplayInfo(tmpStr);

                sprintf(tmpStr, "    Frequency : %2.1f kHz",
                        ac3_frequency[audio_info->frequency]);
                DisplayInfo(tmpStr);
        }
}

/*************************************************************************
	Get_Info_Audio
	holt Informationen zu den einzelnen Audio Access Units
	(Audio frames) ein und speichert sie in einer temporaeren
	Datei ab.
 
	gets information on the single audio access units (audio frames)
	and saves them into a tmp file for further processing.
*************************************************************************/

int get_info_audio (
        char *audio_file,
        char *audio_units,
        Audio_struc *audio_info,
        double *startup_delay,
        unsigned int *audio_total,
        unsigned int length)
{
        FILE* info_file;
        double offset_bits=0.0;
        unsigned int framesize;
        unsigned int padding_bit;
        unsigned int skip;
        unsigned int decoding_order=0;
        double PTS;
        double samples_per_second;
        Aaunit_struc access_unit;
        unsigned int i;
        unsigned int retval, audio_count;
        int percent, oldPercent;
        int exiterror;
        char tmpStr[132];
        bitstream bs;

        exiterror = TRUE;
        audio_count = 0;
        oldPercent = -1;