 expected %s", computedDigest, m.ConfigDescriptor.Digest)
		}
		m.configBlob = blob
	}
	return m.configBlob, nil
}

// OCIConfig returns the image configuration as per OCI v1 image-spec. Information about
// layers in the resulting configuration isn't guaranteed to be returned to due how
// old image manifests work (docker v2s1 especially).
func (m *manifestOCI1) OCIConfig() (*imgspecv1.Image, error) {
	cb, err := m.ConfigBlob()
	if err!= nil {
		return nil, err
	}
	configOCI := &imgspecv1.Image{}
	if err := json.Unmarshal(cb, configOCI); err!= nil {
		return nil, err
	}
	return configOCI, nil
}

// LayerInfos returns a list of BlobInfos of layers referenced by this image, in order (the root layer first, and then successive layered layers).
// The Digest field is guaranteed to be provided; Size may be -1.
// WARNING: The list may contain duplicates, and they are semantically relevant.
func (m *manifestOCI1) LayerInfos() []types.BlobInfo {
	blobs := []types.BlobInfo{}
	for _, layer := range m.LayersDescriptors {
		blobs = append(blobs, types.BlobInfo{Digest: layer.Digest, Size: layer.Size})
	}
	return blobs
}

// EmbeddedDockerReferenceConflicts whether a Docker reference embedded in the manifest, if any, conflicts with destination ref.
// It returns false if the manifest does not embed a Docker reference.
// (This embedding unfortunately happens for Docker schema1, please do not add support for this in any new formats.)
func (m *manifestOCI1) EmbeddedDockerReferenceConflicts(ref reference.Named) bool {
	return false
}

func (m *manifestOCI1) imageInspectInfo() (*types.ImageInspectInfo, error) {
	config, err := m.ConfigBlob()
	if err!= nil {
		return nil, err
	}
	v1 := &v1Image{}
	if err := json.Unmarshal(config, v1); err!= nil {
		return nil, err
	}
	return &types.ImageInspectInfo{
		DockerVersion: v1.DockerVersion,
		Created:       v1.Created,
		Labels:        v1.Config.Labels,
		Architecture:  v1.Architecture,
		Os:            v1.OS,
	}, nil
}

// UpdatedImageNeedsLayerDiffIDs returns true iff UpdatedImage(options) needs InformationOnly.LayerDiffIDs.
// This is a horribly specific interface, but computing InformationOnly.LayerDiffIDs can be very expensive to compute
// (most importantly it forces us to download the full layers even if they are already present at the destination).
func (m *manifestOCI1) UpdatedImageNeedsLayerDiffIDs(options types.ManifestUpdateOptions) bool {
	return false
}

// UpdatedImage returns a types.Image modified according to options.
// This does not change the state of the original Image object.
func (m *manifestOCI1) UpdatedImage(options types.ManifestUpdateOptions) (types.Image, error) {
	copy := *m // NOTE: This is not a deep copy, it still shares slices etc.
	if options.LayerInfos!= nil {
		if len(copy.LayersDescriptors)!= len(options.LayerInfos) {
			return nil, errors.Errorf("Error preparing updated manifest: layer count changed from %d to %d", len(copy.LayersDescriptors), len(options.LayerInfos))
		}
		copy.LayersDescriptors = make([]descriptor, len(options.LayerInfos))
		for i, info := range options.LayerInfos {
			copy.LayersDescriptors[i].Digest = info.Digest
			copy.LayersDescriptors[i].Size = info.Size
		}
	}
	// Ignore options.EmbeddedDockerReference: it may be set when converting from schema1, but we really don't care.

	switch options.ManifestMIMEType {
	case "": // No conversion, OK
	case manifest.DockerV2Schema2MediaType:
		return copy.convertToManifestSchema2()
	default:
		return nil, errors.Errorf("Conversion of image manifest from %s to %s is not implemented", imgspecv1.MediaTypeImageManifest, options.ManifestMIMEType)
	}

	return memoryImageFromManifest(&copy), nil
}

func (m *manifestOCI1) convertToManifestSchema2() (types.Image, error) {
	// Create a copy of the descriptor.
	config := m.ConfigDescriptor

	// The only difference between OCI and DockerSchema2 is the mediatypes. The
	// media type of the manifest is handled by manifestSchema2FromComponents.
	config.MediaType = manifest.DockerV2Schema2ConfigMediaType

	layers := make([]descriptor, len(m.LayersDescriptors))
	for idx := range layers {
		layers[idx] = m.LayersDescriptors[idx]
		layers[idx].MediaType = manifest.DockerV2Schema2LayerMediaType
	}

	// Rather than copying the ConfigBlob now, we just pass m.src to the
	// translated manifest, since the only difference is the mediatype of
	// descriptors there is no change to any blob stored in m.src.
	m1 := manifestSchema2FromComponents(config, m.src, nil, layers)
	return memoryImageFromManifest(m1), nil
}
Discussion in 'The Cheap Seats' started by TryHardNation, Jun 6, 2013.
Does anybody know of a good free video editing software?
This is what I use:
What would be the best software to use for trying to make a montage. I have a bunch of hour long clips that I only need a minute from but it takes forever in most programs because it has to convert the video.
Yeah I'm not sure how you're really going to avoid that from happening unfortunately.
Ddodnt mean importing but some programs like movie maker have to convert the format to a one movie maker can use which ties forever where as that doesn't happen with Somy Vegas.
I also use VideoPad, but I bought the paid version after using the free version for a while.
This program doesn't need to convert video that you import, it accepts a wide range of formats.
Separate names with a comma.The Battle of Delhi also known as the Battle of Tughlaqabad was fought between the forces led by Hemu (the general and chief minister of Adil Shah Suri) and the forces of the Mughal led by Tardi Beg Khan. The battle was fought on 7 October 1556 at Tughlaqabad near Delhi.
After the death of Babur(founder of Mughal empire), Humayun succeeded the throne of Delhi. However after the Battle of Kanauj (17 May 1540) Sher Khan(Sher shah Suri) became the master of Agra and Delhi. Mughal Empire was put to an end for a while and Humayun lived in exile for next 15 years because of this Short Sur Dynasty founded by Sher Shah Suri.
Later Islam Shah Suri ascended the throne of Sur dynasty after the death of Sher Shah in 1545 at Kalinjar. Islam Shah Suri was a capable ruler, but died in 1554. With these two deaths the Sur Empire was caught up in a succession battle. Humayun used this perfect opportunity for the Mughals to march back to India and regain the lost power in 1540. Humayun with Bairam Khan (commander-in-chief of the Mughal army) fought the Battle of Srihind againt Sikandar Shah Suri in 1555 and became victorious. The Mughal Empire was finally regained control over Delhi and Agra after 15 years.
Islam Shah was succeeded by his 12-year-old son, Firoz shah suri. But after a short period Adil Shah Suri maternal uncle of Firoz shah murdered him and ascended the throne of sur Empire. He appointed Hemu (general of the Suri forces) as his Chief Minister. Most of the affairs of the state were left to Hemu as Adil Shah Suri was interested in luxury and pleasure.
Later Humayun died on 27 January 1556 and succeeded by Akbar. Bairam Khan was appointed regent over the young king Akbar. Tardi Beg Khan was the governor of Delhi when Humayun died.
Humayun's death provided a great opportunity for Sur dynasty to defeat Mughals and regain the lost territories. Hearing about the death of Mughal leader, Hemu made a quick march and conquered Sambhal, Bayana, Kal