mp4meta.cpp

完整的RTP RTSP代码库

bool MP4File::GetMetadataGenre(char** value)
{
  u_int16_t genreIndex = 0;
  unsigned char *val = NULL;
  u_int32_t valSize = 0;
  const char *t = "moov.udta.meta.ilst.gnre";
  const char *s = "moov.udta.meta.ilst.gnre.data.metadata";

  *value = NULL;

  MP4Atom *gnre = FindAtom(t);

  if (gnre)
    {
      GetBytesProperty(s, (u_int8_t**)&val, &valSize);

      if (valSize != 2) {
	CHECK_AND_FREE(val);
	return false;
      }

      genreIndex = (u_int16_t)(val[1]);
      genreIndex += (u_int16_t)(val[0]<<8);

      GenreToString(value, genreIndex);

      (void)DeleteMetadataAtom( "gnre" );
      free(val);
      return true;
    } else {
    const char *s2 = "moov.udta.meta.ilst.\251gen.data.metadata";

    val = NULL;
    valSize = 0;

    GetBytesProperty(s2, (u_int8_t**)&val, &valSize);

    if (valSize > 0)
      {
	*value = (char*)malloc((valSize+1)*sizeof(unsigned char));
	if (*value != NULL) {
	  memset(*value, 0, (valSize+1)*sizeof(unsigned char));
	  memcpy(*value, val, valSize*sizeof(unsigned char));
	}
	free(val);
	return true;
      } else {
      CHECK_AND_FREE(val);
    }
  }

  return false;
}

bool MP4File::DeleteMetadataGenre()
{
  bool val1 = DeleteMetadataAtom("\251gen");
  bool val2 = DeleteMetadataAtom("gnre");
  return val1 || val2;
}

bool MP4File::SetMetadataTempo(u_int16_t tempo)
{
  unsigned char t[3];
  const char *s = "moov.udta.meta.ilst.tmpo.data";
  MP4BytesProperty *pMetadataProperty = NULL;
  MP4Atom *pMetaAtom = NULL;
    
  pMetaAtom = m_pRootAtom->FindAtom(s);

  if (!pMetaAtom)
    {
      if (!CreateMetadataAtom("tmpo"))
	return false;

      pMetaAtom = m_pRootAtom->FindAtom(s);
      if (pMetaAtom == NULL) return false;
    }

  memset(t, 0, 3*sizeof(unsigned char));
  t[0] = (unsigned char)(tempo>>8)&0xFF;
  t[1] = (unsigned char)(tempo)&0xFF;

  ASSERT(pMetaAtom->FindProperty("data.metadata", 
				 (MP4Property**)&pMetadataProperty));
  ASSERT(pMetadataProperty);

  pMetadataProperty->SetValue((u_int8_t*)t, 2);

  return true;
}

bool MP4File::GetMetadataTempo(u_int16_t* tempo)
{
  unsigned char *val = NULL;
  u_int32_t valSize = 0;
  const char *s = "moov.udta.meta.ilst.tmpo.data.metadata";

  *tempo = 0;

  GetBytesProperty(s, (u_int8_t**)&val, &valSize);

  if (valSize != 2) {
    CHECK_AND_FREE(val);
    return false;
  }

  *tempo = (u_int16_t)(val[1]);
  *tempo += (u_int16_t)(val[0]<<8);
  free(val);
  return true;
}
bool MP4File::SetMetadataUint8 (const char *atom, uint8_t value)
{
  char atompath[36];
  MP4BytesProperty *pMetadataProperty = NULL;
  MP4Atom *pMetaAtom = NULL;

  snprintf(atompath, 36, "moov.udta.meta.ilst.%s.data", atom);

  pMetaAtom = m_pRootAtom->FindAtom(atompath);

  if (pMetaAtom == NULL) {
    if (!CreateMetadataAtom(atom))
      return false;

    pMetaAtom = m_pRootAtom->FindAtom(atompath);
    if (pMetaAtom == NULL) return false;
  }

  ASSERT(pMetaAtom->FindProperty("data.metadata", 
				 (MP4Property**)&pMetadataProperty));
  ASSERT(pMetadataProperty);
  
  pMetadataProperty->SetValue(&value, 1);

  return true;
}


bool MP4File::GetMetadataUint8(const char *atom, u_int8_t* retvalue)
{
  unsigned char *val = NULL;
  u_int32_t valSize = 0;
  char atompath[80];
  snprintf(atompath, 80, "moov.udta.meta.ilst.%s.data.metadata", atom);

  *retvalue = 0;

  GetBytesProperty(atompath, (u_int8_t**)&val, &valSize);

  if (valSize != 1) {
    CHECK_AND_FREE(val);
    return false;
  }

  *retvalue = val[0];
  free(val);
  return true;
}

bool MP4File::SetMetadataCoverArt(u_int8_t *coverArt, u_int32_t size)
{
  const char *s = "moov.udta.meta.ilst.covr.data";
  MP4BytesProperty *pMetadataProperty = NULL;
  MP4Atom *pMetaAtom = NULL;
    
  pMetaAtom = m_pRootAtom->FindAtom(s);

  if (!pMetaAtom)
    {
      if (!CreateMetadataAtom("covr"))
	return false;

      pMetaAtom = m_pRootAtom->FindAtom(s);
      if (pMetaAtom == NULL) return false;
    }

  ASSERT(pMetaAtom->FindProperty("data.metadata", 
				 (MP4Property**)&pMetadataProperty));
  ASSERT(pMetadataProperty);

  pMetadataProperty->SetValue(coverArt, size);

  return true;
}

bool MP4File::GetMetadataCoverArt(u_int8_t **coverArt, u_int32_t *size,
				  uint32_t index)
{
  char buffer[256];
  if (size == NULL || coverArt == NULL) return false;

  if (index > 0 && index > GetMetadataCoverArtCount()) return false;

  snprintf(buffer, 256, "moov.udta.meta.ilst.covr.data[%d].metadata", index);

  *coverArt = NULL;
  *size = 0;

  GetBytesProperty(buffer, coverArt, size);

  if (size == 0)
    return false;

  return true;
}

u_int32_t MP4File::GetMetadataCoverArtCount (void)
{
  MP4Atom *pMetaAtom = m_pRootAtom->FindAtom("moov.udta.meta.ilst.covr");
  if (!pMetaAtom)
    return 0;

  return pMetaAtom->GetNumberOfChildAtoms();
}

bool MP4File::SetMetadataFreeForm (const char *name, 
				   const u_int8_t* pValue, 
				   u_int32_t valueSize,
				   const char *owner)
{
  MP4Atom *pMetaAtom = NULL;
  MP4BytesProperty *pMetadataProperty = NULL;
  char s[256];
  int i = 0;
  size_t nameLen = strlen(name);
  size_t ownerLen = owner != NULL ? strlen(owner) : 0;

  while (1)
    {
      snprintf(s, 256, "moov.udta.meta.ilst.----[%u].name", i);

      MP4Atom *pTagAtom = m_pRootAtom->FindAtom(s);

      if (!pTagAtom)
	break;

      snprintf(s, 256, "moov.udta.meta.ilst.----[%u].mean", i);

      MP4Atom *pMeanAtom = m_pRootAtom->FindAtom(s);

      if (pTagAtom->FindProperty("name.metadata", 
				 (MP4Property**)&pMetadataProperty) &&
	  pMetadataProperty) {
	u_int8_t* pV;
	u_int32_t VSize = 0;

	pMetadataProperty->GetValue(&pV, &VSize);

	if (VSize == nameLen && memcmp(pV, name, VSize) == 0) {
	  u_int8_t* pOwner=0;
	  u_int32_t ownerSize = 0;
	  
	  if (pMeanAtom && 
	      pMeanAtom->FindProperty("mean.metadata", 
				      (MP4Property**)&pMetadataProperty) &&
	      pMetadataProperty) {
	    pMetadataProperty->GetValue(&pOwner, &ownerSize);
	  }
	  
	  if (owner == NULL|| 
	      (pOwner && 
	       ownerLen == ownerSize && 
	       memcmp(owner, pOwner, ownerSize))) {
	    snprintf(s, 256, "moov.udta.meta.ilst.----[%u].data.metadata", i);
	    SetBytesProperty(s, pValue, valueSize);
	    CHECK_AND_FREE(pV);
	    CHECK_AND_FREE(pOwner);
	    
	    return true;
	  }
	  CHECK_AND_FREE(pOwner);
	}
	CHECK_AND_FREE(pV);
      }
      
      i++;
    }

  /* doesn't exist yet, create it */
  char t[256];

  snprintf(t, 256, "udta.meta.ilst.----[%u]", i);
  snprintf(s, 256, "moov.udta.meta.ilst.----[%u].data", i);
  (void)AddDescendantAtoms("moov", t);

  pMetaAtom = m_pRootAtom->FindAtom(s);

  if (!pMetaAtom)
    return false;

  pMetaAtom->SetFlags(0x1);

  MP4Atom *pHdlrAtom = m_pRootAtom->FindAtom("moov.udta.meta.hdlr");
  MP4StringProperty *pStringProperty = NULL;
  MP4BytesProperty *pBytesProperty = NULL;
  ASSERT(pHdlrAtom);

  ASSERT(pHdlrAtom->FindProperty("hdlr.handlerType", 
				 (MP4Property**)&pStringProperty));
  ASSERT(pStringProperty);
  pStringProperty->SetValue("mdir");

  u_int8_t val[12];
  memset(val, 0, 12*sizeof(u_int8_t));
  val[0] = 0x61;
  val[1] = 0x70;
  val[2] = 0x70;
  val[3] = 0x6c;
  ASSERT(pHdlrAtom->FindProperty("hdlr.reserved2", 
				 (MP4Property**)&pBytesProperty));
  ASSERT(pBytesProperty);
  pBytesProperty->SetReadOnly(false);
  pBytesProperty->SetValue(val, 12);
  pBytesProperty->SetReadOnly(true);

  pMetaAtom = m_pRootAtom->FindAtom(s);
  ASSERT(pMetaAtom);
  ASSERT(pMetaAtom->FindProperty("data.metadata", 
				 (MP4Property**)&pMetadataProperty));
  ASSERT(pMetadataProperty);
  pMetadataProperty->SetValue(pValue, valueSize);

  snprintf(s, 256, "moov.udta.meta.ilst.----[%u].name", i);
  pMetaAtom = m_pRootAtom->FindAtom(s);
  ASSERT(pMetaAtom->FindProperty("name.metadata", 
				 (MP4Property**)&pMetadataProperty));
  ASSERT(pMetadataProperty);
  pMetadataProperty->SetValue((const u_int8_t*)name, strlen(name));

  snprintf(s, 256, "moov.udta.meta.ilst.----[%u].mean", i);
  pMetaAtom = m_pRootAtom->FindAtom(s);
  ASSERT(pMetaAtom->FindProperty("mean.metadata", 
				 (MP4Property**)&pMetadataProperty));
  ASSERT(pMetadataProperty);
  if (!owner || !*owner)
    pMetadataProperty->SetValue((u_int8_t*)"com.apple.iTunes", 16); /* com.apple.iTunes is the default*/
  else
    pMetadataProperty->SetValue((const u_int8_t*)owner, strlen((const char *)owner));

  return true;
}

bool MP4File::GetMetadataFreeForm(const char *name, 
				  u_int8_t** ppValue, 
				  u_int32_t *pValueSize,
				  const char *owner)
{
  char s[256];
  int i = 0;

  *ppValue = NULL;
  *pValueSize = 0;

  size_t nameLen = strlen(name);
  size_t ownerLen = owner?strlen(owner):0;

  while (1)
    {
      MP4BytesProperty *pMetadataProperty;

      snprintf(s, 256,"moov.udta.meta.ilst.----[%u].name", i);
      MP4Atom *pTagAtom = m_pRootAtom->FindAtom(s);

      snprintf(s, 256,"moov.udta.meta.ilst.----[%u].mean", i);
      MP4Atom *pMeanAtom = m_pRootAtom->FindAtom(s);

      if (!pTagAtom)
	return false;

      if (pTagAtom->FindProperty("name.metadata", 
				 (MP4Property**)&pMetadataProperty) &&
	  pMetadataProperty) {
	u_int8_t* pV;
	u_int32_t VSize = 0;

	pMetadataProperty->GetValue(&pV, &VSize);

	if (VSize == nameLen && memcmp(pV, name, VSize) == 0) {
	    u_int8_t* pOwner=0;
	    u_int32_t ownerSize = 0;

	    if (pMeanAtom && pMeanAtom->FindProperty("mean.metadata", 
						     (MP4Property**)&pMetadataProperty) &&
		pMetadataProperty) {
	      pMetadataProperty->GetValue(&pOwner, &ownerSize);
	    }

	    if (!owner || (pOwner && ownerLen == ownerSize && memcmp(owner, pOwner, ownerSize))) {
	      snprintf(s, 256, "moov.udta.meta.ilst.----[%u].data.metadata", i);
	      GetBytesProperty(s, ppValue, pValueSize);
	      CHECK_AND_FREE(pV);
	      CHECK_AND_FREE(pOwner);
	      return true;	
	    }
	    CHECK_AND_FREE(pOwner);
	}
	CHECK_AND_FREE(pV);
      }
      
      i++;
    }
}

bool MP4File::DeleteMetadataFreeForm(const char *name, const char *owner)
{
  char s[256];
  int i = 0;

  size_t nameLen = strlen(name);
  size_t ownerLen = owner?strlen(owner):0;

  while (1)
    {
      MP4BytesProperty *pMetadataProperty;

      snprintf(s, 256, "moov.udta.meta.ilst.----[%u].name", i);
      MP4Atom *pTagAtom = m_pRootAtom->FindAtom(s);

      snprintf(s, 256,"moov.udta.meta.ilst.----[%u].mean", i);
      MP4Atom *pMeanAtom = m_pRootAtom->FindAtom(s);


      if (!pTagAtom)
	return false;

      if (pTagAtom->FindProperty("name.metadata", 
				 (MP4Property**)&pMetadataProperty) &&
	  pMetadataProperty) {
	u_int8_t* pV;
	u_int32_t VSize = 0;

	pMetadataProperty->GetValue(&pV, &VSize);

	if (VSize != 0)
	  {
	    if (VSize == nameLen && memcmp(pV, name, VSize) == 0)
	      {
		u_int8_t* pOwner=0;
		u_int32_t ownerSize = 0;

		if (pMeanAtom && pMeanAtom->FindProperty("mean.metadata", 
							 (MP4Property**)&pMetadataProperty) &&
		    pMetadataProperty) 
		  {
		    pMetadataProperty->GetValue(&pOwner, &ownerSize);
		  }

		if (!owner || (pOwner && ownerLen == ownerSize && memcmp(owner, pOwner, ownerSize)))
		  {
		    snprintf(s, 256, "----[%u]", i);
		    CHECK_AND_FREE(pOwner);
		    CHECK_AND_FREE(pV);
		    return DeleteMetadataAtom(s);
		  }
		CHECK_AND_FREE(pOwner);

	      }
	  }
	CHECK_AND_FREE(pV);
      }

      i++;
    }
}

bool MP4File::MetadataDelete()
{
  MP4Atom *pMetaAtom = NULL;
  char s[256];

  snprintf(s, 256, "moov.udta.meta");
  pMetaAtom = m_pRootAtom->FindAtom(s);

  /* if it exists, delete it */
  if (pMetaAtom)
    {
      MP4Atom *pParent = pMetaAtom->GetParentAtom();

      pParent->DeleteChildAtom(pMetaAtom);

      delete pMetaAtom;

      return true;
    }

  return false;
}