umc_mp4_spl.cpp

audio-video-codecs.rar语音编解码器

        nBufferSize = MINVIDEOBUFFERSIZE;
    }

    mParams.m_prefInputBufferSize =  mParams.m_prefOutputBufferSize = nBufferSize;
    UMC_CALL(m_ppMediaBuffer[iES]->Init(&mParams));
  }

  // update splitter flag
  if (nVideo == 0) {
    m_pInfo->m_splitter_flags &= ~VIDEO_SPLITTER;
  }
  if (nAudio == 0) {
    m_pInfo->m_splitter_flags &= ~AUDIO_SPLITTER;
  }

  if (m_headerMPEG4.moov.mvex.total_tracks) { // there are fragments
    umcRes = m_InitMoofThread.Create((vm_thread_callback)InitMoofThreadCallback,(void *)this);
  }

  return umcRes;
}

Status MP4Splitter::Close()
{
  Ipp32u iES;
  Status umcRes = CheckInit();

  if (umcRes != UMC_OK)
    return umcRes;

  SplitterBase::Close();

  for (iES = 0; iES < m_pInfo->m_nOfTracks; iES++) {
    Clear_track(m_headerMPEG4.moov.trak[iES]);

//    UMC_CALL(m_ppMediaBuffer[iES]->Close());
    UMC_DELETE(m_ppMediaBuffer[iES])
    UMC_DELETE(m_ppLockedFrame[iES])
    UMC_DELETE(m_ppMediaBuffer[iES])
    delete m_pInfo->m_ppTrackInfo[iES]->m_pDecSpecInfo;
    delete m_pInfo->m_ppTrackInfo[iES]->m_pStreamInfo;
    delete m_pInfo->m_ppTrackInfo[iES];
  }

  /* if there are extended tracks */
  umcRes = Clear_moof(m_headerMPEG4.moof);
  UMC_CHECK_STATUS(umcRes)

  for (iES = 0; iES < m_headerMPEG4.moov.mvex.total_tracks; iES++) {
    UMC_FREE(m_headerMPEG4.moov.mvex.trex[iES])
  }

  UMC_FREE(m_pLastPTS)
  UMC_DELETE_ARR(m_pReadESThread)

  UMC_FREE(m_ppLockedFrame)
  UMC_FREE(m_ppMediaBuffer)
  UMC_FREE(m_pInfo->m_ppTrackInfo)

  if (m_pTrackIndex) {
    delete[] m_pTrackIndex;
    m_pTrackIndex = NULL;
  }

  if (m_pInfo) {
    delete m_pInfo;
    m_pInfo = NULL;
  }

  return UMC_OK;
}

/*
extern Ipp32s GetIntraSizeValue(Ipp8u * buf, Ipp8u nSize)
{
    switch(nSize)
    {
        case 2: return ((*buf) << 8)  | (*(buf + 1));
        case 3: return ((*buf) << 16) | (*(buf + 1) << 8) |  (*(buf + 2));
        case 4: return ((*buf) << 24) | (*(buf + 1) << 16) | (*(buf + 2) << 8) | (*(buf + 3));
    }
    return 0;
}
*/

/*
void SplitterMP4::GetPictureType(Ipp32s nTrack, SplSample* pSample)
{
  // unreferenced parameter, to disable compiler warning C4100
  UNREFERENCED_PARAMETER(nTrack);

  if (!pSample || !m_pDataReader)
      return;

  unsigned char   buf[70];
  Ipp32u          nSizeToRead = 64 + 5; //64 is maximum size for header

  vm_debug_trace(VM_DEBUG_ERROR, VM_STRING("call m_dataReaderMutex.Lock\n"));
  m_dataReaderMutex.Lock();
  vm_debug_trace(VM_DEBUG_ERROR, VM_STRING("end call m_dataReaderMutex.Lock\n"));

  m_pDataReader->SetPosition(pSample->m_nPosition);
  m_pDataReader->GetData(buf, &nSizeToRead);

  if (MPEG4_VIDEO == m_eVideoStreamType) {
    Ipp32u          nStartCodePosition = 0;
    bool            bStartCode = false;

    for (unsigned int i = 0; i < nSizeToRead; i++) {
      if (0xb6 == (unsigned int)buf[i]) {
        nStartCodePosition = i;
        bStartCode = true;
        break;
      }
    }

    if (bStartCode) {
      int nCodingType = 0;
      int nBytePos = nStartCodePosition + 1; // start code

      BitStreamReader bsReader;
      bsReader.Init(buf + nBytePos);
      nCodingType = bsReader.GetBits(2);

      switch (nCodingType) {
      case 0:
        pSample->m_frameType = I_PICTURE;
        break;
      case 1:
        pSample->m_frameType = P_PICTURE;
        break;
      case 2:
        pSample->m_frameType = B_PICTURE;
        break;
      case 3:
        pSample->m_frameType = D_PICTURE; // SPRITE picture?
        break;
      }
    }

  } else if (H264_VIDEO == m_eVideoStreamType) {
    Ipp32s iCode = 0;
    int nIntraSize = 0;
    int nFrameSize = 0;

    bool bSkip = true;
    while(bSkip) {
      iCode = buf[m_nH264FrameIntraSize];

      if (NAL_UT_IDR_SLICE == (iCode & NAL_UNITTYPE_BITS)) {
        pSample->m_frameType = I_PICTURE;
        break;
      } else if (NAL_UT_SLICE == (iCode & NAL_UNITTYPE_BITS)) {
        break;
      } else {
        nIntraSize = GetIntraSizeValue(buf, m_nH264FrameIntraSize);
        nFrameSize += nIntraSize;

        if (nFrameSize >= pSample->m_nSize)
            break;

        m_pDataReader->MovePosition(nIntraSize -  nSizeToRead + m_nH264FrameIntraSize);
        m_pDataReader->GetData(buf, &nSizeToRead);
      }
    }
  }
  vm_debug_trace(VM_DEBUG_ERROR, VM_STRING("call m_dataReaderMutex.UnLock\n"));
  m_dataReaderMutex.Unlock();
  vm_debug_trace(VM_DEBUG_ERROR, VM_STRING("end call m_dataReaderMutex.UnLock\n"));
}
*/

/*
Status MP4Splitter::GetInfo(SplitterInfo* pInfo) { // TEMPORAL !!!
  pInfo->m_system_info.stream_type = m_pInfo->systemType;
  pInfo->m_splitter_flags = m_pInfo->m_splitter_flags;

  / * filling number of tracks * /
  for (Ipp32u i = 0; i < m_pInfo->nOfTracks; i++) {
    if(m_pInfo->ppTrackInfo[i]->type & TRACK_ANY_AUDIO) {
      pInfo->number_audio_tracks++;
    } else if(m_pInfo->ppTrackInfo[i]->type & TRACK_ANY_VIDEO) {
      pInfo->number_video_tracks++;
    }
  }

  if ((pInfo->number_audio_tracks > 0) && (m_pInfo->m_splitter_flags & AUDIO_SPLITTER)) {
    sAudio_specific_config  audio_config_data;
    sBitsreamBuffer         bs;
    int i;

    Ipp32u num = 0;
//    Ipp32u uiPin = GetTrackNumber(TRACK_ANY_AUDIO, num, m_pInfo); // search for the first audio track
    Ipp32u uiPin = pAudioTrTbl[num];

    Ipp32s m_DecInfolen = m_pInfo->ppTrackInfo[uiPin]->nDecSpecInfoLen;
    T_mdia_data m_Mdia = m_headerMPEG4.moov.trak[uiPin]->mdia;

    //get info from esds atom
    if (m_DecInfolen) {
      bs.nBit_offset = 32;
      bs.pCurrent_dword = bs.pBuffer = (Ipp32u*)m_pInfo->ppTrackInfo[uiPin]->pDecSpecInfo;
      if (!dec_audio_specific_config(&audio_config_data,&bs)) {
        //dec_audio_specific_config returns 0, if everything is OK.
        pInfo->m_audio_info.stream_type = AudioObjectTypeID(audio_config_data.audioObjectType);
        pInfo->m_audio_info.sample_frequency = get_sampling_frequency(&audio_config_data, 0);

        if (1 == audio_config_data.sbrPresentFlag) {
          pInfo->m_audio_info.sample_frequency = get_sampling_frequency(&audio_config_data, 1);
        }

        pInfo->m_audio_info.channels = get_channels_number(&audio_config_data);
      }
    }
    //or get info from   damr atom for AMR audio
    else if (m_Mdia.minf.stbl.stsd.table->damr.decoderConfigLen) {
      pInfo->m_audio_info.sample_frequency = 8000;
      pInfo->m_audio_info.channels = 1;
      pInfo->m_audio_info.stream_type = AMR_NB_AUDIO;
    }

    //get info about stream
    if (UNDEF_AUDIO ==  pInfo->m_audio_info.stream_type) {
      //get channels num
      pInfo->m_audio_info.channels = m_Mdia.minf.stbl.stsd.table->channels;

      //get sample frequency
      pInfo->m_audio_info.sample_frequency = m_Mdia.minf.stbl.stsd.table->sample_rate;

      //get audio stream type
      pInfo->m_audio_info.stream_type = GetAudioStreamType(m_Mdia.minf.stbl.stsd.table->esds.objectTypeID);

      //if audio stream type is AAC, then if the content protected is checked
      if (AAC_MPEG4_STREAM == pInfo->m_audio_info.stream_type &&
        m_Mdia.minf.stbl.stsd.table->is_protected) {
          pInfo->m_audio_info.is_protected = 1;
      }
    }

    //get channels mask
    pInfo->m_audio_info.channel_mask = GetChannelMask(pInfo->m_audio_info.channels);
    //get bitrate
    pInfo->m_audio_info.bitrate = m_Mdia.minf.stbl.stsd.table->esds.avgBitrate;
    pInfo->m_audio_info.bitPerSample = 0;
    //get duration
    pInfo->m_audio_info.duration = ((float)(Ipp64s)(m_Mdia.mdhd.duration) /
                                    (float)m_Mdia.mdhd.time_scale);

    //if any additional audio track
    if (pInfo->number_audio_tracks > 1) {
      if(pInfo->m_audio_info_aux) {
        ippsFree(pInfo->m_audio_info_aux);
      }
/ *
      unsigned int buff_size = (m_nTotalAudioTrack - 1) * sizeof(sAudioStreamInfo);
      pInfo->m_audio_info_aux = (sAudioStreamInfo*)ippsMalloc_8u(buff_size);

      if(pInfo->m_audio_info_aux) {
        memset(pInfo->m_audio_info_aux, 0, buff_size);
      } else {
        vm_debug_trace(VM_DEBUG_PROGRESS, VM_STRING("MP4 Splitter: Not Enough Mem"));
        return UMC_ERR_FAILED;
      }

      for (i = 0; i < m_nTotalAudioTrack - 1; i++) {
        num++;
        uiPin = GetTrackNumber(AUDIO_TRACK, num);

        m_Mdia = m_headerMPEG4.moov.trak[uiPin]->mdia;

        if (m_Mdia.minf.stbl.stsd.table->esds.decoderConfigLen) {
          bs.nBit_offset = 32;
          bs.pCurrent_dword =
              bs.pBuffer = (Ipp32u*) m_Mdia.minf.stbl.stsd.table->esds.decoderConfig;

          dec_audio_specific_config(&audio_config_data,&bs);

          pInfo->m_audio_info_aux[i].stream_type = ObjectIDType(audio_config_data.audioObjectType);
          pInfo->m_audio_info_aux[i].sample_frequency = get_sampling_frequency(&audio_config_data, 0);

          if (1 == audio_config_data.sbrPresentFlag) {
            pInfo->m_audio_info_aux[i].sample_frequency = get_sampling_frequency(&audio_config_data, 1);
          }

          pInfo->m_audio_info_aux[i].channels = get_channels_number(&audio_config_data);
        } else if (m_Mdia.minf.stbl.stsd.table->damr.decoderConfigLen) {
          pInfo->m_audio_info_aux[i].sample_frequency = 8000;
          pInfo->m_audio_info_aux[i].channels = 1;
          pInfo->m_audio_info_aux[i].stream_type = AMR_NB_AUDIO;
        }

        if (UMC::UNDEF_AUDIO == pInfo->m_audio_info_aux[i].stream_type) {
          pInfo->m_audio_info_aux[i].channels = m_Mdia.minf.stbl.stsd.table->channels;
          pInfo->m_audio_info_aux[i].sample_frequency = m_Mdia.minf.stbl.stsd.table->sample_rate;

          //get audio stream type
          GetAudioStreamType(m_Mdia.minf.stbl.stsd.table->esds.objectTypeID, &pInfo->m_audio_info_aux[i]);
        }

        if (AAC_MPEG4_STREAM == pInfo->m_audio_info_aux[i].stream_type &&
          m_Mdia.minf.stbl.stsd.table->is_protected) {
          pInfo->m_audio_info_aux[i].is_protected = 1;
        }

        pInfo->m_audio_info_aux[i].channel_mask = GetChannelsMask(pInfo->m_audio_info.channels);
        pInfo->m_audio_info_aux[i].bitrate = m_Mdia.minf.stbl.stsd.table->esds.avgBitrate;
        pInfo->m_audio_info_aux[i].bitPerSample = 0;
        pInfo->m_audio_info_aux[i].duration = ((Ipp32f)(Ipp64s)(m_Mdia.mdhd.duration) /
                                               (Ipp32f)m_Mdia.mdhd.time_scale);

        pInfo->m_audio_info_aux[i].bitPerSample  = 16;
      } // for ( total_audio )* /
    } // if ( total_audio > 1 )
    pInfo->m_audio_info.bitPerSample  = 16;
  } // if ( total_audio )

  if ((pInfo->number_video_tracks > 0) && (m_pInfo->m_splitter_flags & VIDEO_SPLITTER)) {

    Status umcRes;
    Ipp32u num = 0;
//    Ipp32u uiPin = GetTrackNumber(TRACK_ANY_VIDEO, num, m_pInfo); // search for the first video track
    Ipp32u uiPin = pVideoTrTbl[num];

//    Ipp32s m_DecInfolen = m_pInfo->ppTrackInfo[uiPin]->nDecSpecInfoLen;

    T_mdia_data m_Mdia = m_headerMPEG4.moov.trak[uiPin]->mdia;
    int i;

    //default values (not from ESDS info)
    pInfo->m_video_info.clip_info.width  = (int)m_Mdia.minf.stbl.stsd.table->width;
    pInfo->m_video_info.clip_info.height = (int)m_Mdia.minf.stbl.stsd.table->height;
    pInfo->m_video_info.aspect_ratio_height = 1;
    pInfo->m_video_info.aspect_ratio_width = 1;

    if (m_pInfo->ppTrackInfo[uiPin]->nDecSpecInfoLen) {
      pInfo->m_video_info = *(DynamicCast<VideoStreamInfo>(m_pInfo->ppTrackInfo[uiPin]->pStreamInfo));
    }

/ *
    if (m_Mdia.minf.stbl.stsd.table->esds.decoderConfigLen) {
      //get info about stream from ESDS info
      umcRes = ParseESDSHeader(m_Mdia.minf.stbl.stsd.table->esds, &pInfo->m_video_info, uiPin);
      UMC_CHECK_STATUS(umcRes)
    } else if (m_Mdia.minf.stbl.stsd.table->avcC.decoderConfigLen) {
      //get info about stream from avcC info
      umcRes = ParseAVCCHeader(m_Mdia.minf.stbl.stsd.table->avcC, &pInfo->m_video_info);
      UMC_CHECK_STATUS(umcRes)
    }
* /

/ *    //get bitrate
    pInfo->m_video_info.bitrate = m_Mdia.minf.stbl.stsd.table->esds.avgBitrate;

    //get duration
    pInfo->m_video_info.duration = ((float)(Ipp64s)(m_Mdia.mdhd.duration) /
                                    (float)m_Mdia.mdhd.time_scale);

      if (pInfo->m_video_info.duration > 0 && !m_headerMPEG4.moov.mvex.total_tracks) {
          pInfo->m_video_info.framerate = (m_Mdia.minf.stbl.stsz.total_entries) /
                                           pInfo->m_video_info.duration;
      } else {
        if (m_headerMPEG4.moov.mvex.total_tracks && m_headerMPEG4.moov.mvex.trex[uiPin]->default_sample_duration) {
            pInfo->m_video_info.framerate = m_Mdia.mdhd.time_scale/
              m_headerMPEG4.moov.mvex.trex[uiPin]->default_sample_duration;
        } else {
          if (m_headerMPEG4.moov.mvex.trex[uiPin] &&
              m_headerMPEG4.moov.mvex.trex[uiPin]->default_sample_duration) {
            pInfo->m_video_info.framerate = m_headerMPEG4.moov.mvex.trex[uiPin]->default_sample_duration;
          }
          //if duration was changed, after parsing of the all stream fragments
          else if (m_pFirstSegmentDuration && m_pFirstSegmentDuration[uiPin] > 0) {
              pInfo->m_video_info.framerate = (Ipp64f)(m_Mdia.minf.stbl.stsz.total_entries) /
                                                  m_pFirstSegmentDuration[uiPin];
            pInfo->m_video_info.framerate *= m_Mdia.mdhd.time_scale;
          } else {
            pInfo->m_video_info.framerate = 0;
          }
        }
    }

    //get stream type
    GetVideoStreamType(m_Mdia.minf.stbl.stsd.table->esds.objectTypeID, &pInfo->m_video_info);
    m_eVideoStreamType = pInfo->m_video_info.stream_type;

    //if any additional video track, then information about them is also filled
    if ( m_nTotalVideoTrack > 1 ) {
      //alloc memory
      if (pInfo->m_video_info_aux) {
          ippsFree(pInfo->m_video_info_aux);
      }
      unsigned int buff_size = (m_nTotalVideoTrack - 1)* sizeof(sVideoStreamInfo);
      pInfo->m_video_info_aux = (sVideoStreamInfo*)ippsMalloc_8u(buff_size);
      if (pInfo->m_video_info_aux) {
          memset(pInfo->m_video_info_aux, 0, buff_size);
      } else {
        vm_debug_trace(VM_DEBUG_PROGRESS, VM_STRING("MP4 Splitter: Not Enough Mem"));
        return UMC_ERR_FAILED;
      }

      for (i = 0; i < m_nTotalVideoTrack - 1; i++) {
        num++;
        uiPin = GetTrackNumber(VIDEO_TRACK, num);

        m_Mdia = m_headerMPEG4.moov.trak[uiPin]->mdia;

        //default values
        pInfo->m_video_info_aux[i].clip_info.width  = (int)m_Mdia.minf.stbl.stsd.table->width;
        pInfo->m_video_info_aux[i].clip_info.height = (int)m_Mdia.minf.stbl.stsd.table->height;

        // find start code VideoObjectLayer and parse width and height
        ParseESDSHeader(m_Mdia.minf.stbl.stsd.table->esds, &pInfo->m_video_info_aux[i], uiPin);

        pInfo->m_video_info_aux[i].bitrate = m_Mdia.minf.stbl.stsd.table->esds.avgBitrate;

        pInfo->m_video_info_aux[i].duration = ((float)(Ipp64s)(m_Mdia.mdhd.duration) /
            (float)m_Mdia.mdhd.time_scale);

        pInfo->m_video_info_aux[i].framerate = m_Mdia.minf.stbl.stsz.total_entries /
            pInfo->m_video_info_aux[i].duration;

        GetVideoStreamType(m_Mdia.minf.stbl.stsd.table->esds.objectTypeID, &pInfo->m_video_info_aux[i]);
      }// for
    }// if* /
  }// if


  return UMC_OK;
}


*/



} // namespace UMC