symuluj rozmiar tła: okładka na <video> lub <img>

W przypadku niektórych przeglądarek możesz użyć

object-fit: cover;

http://caniuse.com/object-fit

Oto jak to zrobiłem. Działający przykład znajduje się w tym jsFiddle .

var min_w = 300; // minimum video width allowed
var vid_w_orig;  // original video dimensions
var vid_h_orig;

jQuery(function() { // runs after DOM has loaded

  vid_w_orig = parseInt(jQuery('video').attr('width'));
  vid_h_orig = parseInt(jQuery('video').attr('height'));
  $('#debug').append("<p>DOM loaded</p>");

  jQuery(window).resize(function () { resizeToCover(); });
  jQuery(window).trigger('resize');
});

function resizeToCover() {
  // set the video viewport to the window size
  jQuery('#video-viewport').width(jQuery(window).width());
  jQuery('#video-viewport').height(jQuery(window).height());

  // use largest scale factor of horizontal/vertical
  var scale_h = jQuery(window).width() / vid_w_orig;
  var scale_v = jQuery(window).height() / vid_h_orig;
  var scale = scale_h > scale_v ? scale_h : scale_v;

  // don't allow scaled width < minimum video width
  if (scale * vid_w_orig < min_w) {scale = min_w / vid_w_orig;};

  // now scale the video
  jQuery('video').width(scale * vid_w_orig);
  jQuery('video').height(scale * vid_h_orig);
  // and center it by scrolling the video viewport
  jQuery('#video-viewport').scrollLeft((jQuery('video').width() - jQuery(window).width()) / 2);
  jQuery('#video-viewport').scrollTop((jQuery('video').height() - jQuery(window).height()) / 2);

  // debug output
  jQuery('#debug').html("<p>win_w: " + jQuery(window).width() + "</p>");
  jQuery('#debug').append("<p>win_h: " + jQuery(window).height() + "</p>");
  jQuery('#debug').append("<p>viewport_w: " + jQuery('#video-viewport').width() + "</p>");
  jQuery('#debug').append("<p>viewport_h: " + jQuery('#video-viewport').height() + "</p>");
  jQuery('#debug').append("<p>video_w: " + jQuery('video').width() + "</p>");
  jQuery('#debug').append("<p>video_h: " + jQuery('video').height() + "</p>");
  jQuery('#debug').append("<p>vid_w_orig: " + vid_w_orig + "</p>");
  jQuery('#debug').append("<p>vid_h_orig: " + vid_h_orig + "</p>");
  jQuery('#debug').append("<p>scale: " + scale + "</p>");
};

#video-viewport {
  position: absolute;
  top: 0;
  overflow: hidden;
  z-index: -1; /* for accessing the video by click */
}

#debug {
  position: absolute;
  top: 0;
  z-index: 100;
  color: #fff;
  font-size: 12pt;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id="video-viewport">
  <video autoplay controls preload width="640" height="360">
    <source src="http://www.quirksmode.org/html5/videos/big_buck_bunny.mp4"type="video/mp4" />
    <source src="http://www.quirksmode.org/html5/videos/big_buck_bunny.webm"type="video/webm" />
    <source src="http://www.quirksmode.org/html5/videos/big_buck_bunny.ogv"type="video/webm" />
  </video>
</div>

<div id="debug"></div>

Pozostałe odpowiedzi były dobre, ale obejmują javascript lub nie wyśrodkowują wideo w poziomie ORAZ w pionie.

Możesz użyć tego pełnego rozwiązania CSS, aby uzyskać wideo, które symuluje właściwość background-size: cover:

  video {
    position: fixed;           // Make it full screen (fixed)
    right: 0;
    bottom: 0;
    z-index: -1;               // Put on background

    min-width: 100%;           // Expand video
    min-height: 100%;
    width: auto;               // Keep aspect ratio
    height: auto;

    top: 50%;                  // Vertical center offset
    left: 50%;                 // Horizontal center offset

    -webkit-transform: translate(-50%,-50%);
    -moz-transform: translate(-50%,-50%);
    -ms-transform: translate(-50%,-50%);
    transform: translate(-50%,-50%);         // Cover effect: compensate the offset

    background: url(bkg.jpg) no-repeat;      // Background placeholder, not always needed
    background-size: cover;
  }

Na podstawie odpowiedzi i komentarzy Daniela de Wita szukałem nieco więcej. Dzięki za rozwiązanie.

Rozwiązaniem jest użycie, object-fit: cover;które ma świetne wsparcie ( obsługuje to każda nowoczesna przeglądarka). Jeśli naprawdę chcesz obsługiwać IE, możesz użyć wypełnienia typu polifill, takiego jak object-fit-images lub object-fit .

Dema:

img {
  float: left;
  width: 100px;
  height: 80px;
  border: 1px solid black;
  margin-right: 1em;
}
.fill {
  object-fit: fill;
}
.contain {
  object-fit: contain;
}
.cover {
  object-fit: cover;
}
.none {
  object-fit: none;
}
.scale-down {
  object-fit: scale-down;
}

<img class="fill" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
<img class="contain" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
<img class="cover" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
<img class="none" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
<img class="scale-down" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>

iz rodzicem:

div {
  float: left;
  width: 100px;
  height: 80px;
  border: 1px solid black;
  margin-right: 1em;
}
img {
  width: 100%;
  height: 100%;
}
.fill {
  object-fit: fill;
}
.contain {
  object-fit: contain;
}
.cover {
  object-fit: cover;
}
.none {
  object-fit: none;
}
.scale-down {
  object-fit: scale-down;
}

<div>
<img class="fill" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
</div><div>
<img class="contain" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
</div><div>
<img class="cover" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
</div><div>
<img class="none" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
</div><div>
<img class="scale-down" src="http://www.peppercarrot.com/data/wiki/medias/img/chara_carrot.jpg"/>
</div>

Rozwiązanie M-Pixel jest świetne, ponieważ rozwiązuje problem skalowania odpowiedzi Timothy'ego (wideo będzie skalowane w górę, ale nie w dół, więc jeśli Twój film jest naprawdę duży, są duże szanse, że zobaczysz tylko niewielką część powiększoną). Jednak rozwiązanie to opiera się na fałszywych założeniach dotyczących rozmiaru kontenera wideo, a mianowicie, że musi to być 100% szerokości i wysokości widocznego obszaru. Znalazłem kilka przypadków, w których to nie zadziałało, więc postanowiłem sam rozwiązać problem i uważam, że znalazłem ostateczne rozwiązanie .

HTML

<div class="parent-container">
    <div class="video-container">
        <video width="1920" height="1080" preload="auto" autoplay loop>
            <source src="video.mp4" type="video/mp4">
        </video>
    </div>
</div>

CSS

.parent-container {
  /* any width or height */
  position: relative;
  overflow: hidden;
}
.video-container {
  width: 100%;
  min-height: 100%;
  position: absolute;
  left: 0px;
  /* center vertically */
  top: 50%;
  -moz-transform: translate(0%, -50%);
  -ms-transform: translate(0%, -50%);
  -webkit-transform: translate(0%, -50%);
  transform: translate(0%, -50%);
}
.video-container::before {
  content: "";
  display: block;
  height: 0px;
  padding-bottom: 56.25%; /* 100% * 9 / 16 */
}
.video-container video {
  width: auto;
  height: 100%;
  position: absolute;
  top: 0px;
  /* center horizontally */
  left: 50%;
  -moz-transform: translate(-50%, 0%);
  -ms-transform: translate(-50%, 0%);
  -webkit-transform: translate(-50%, 0%);
  transform: translate(-50%, 0%);
}

Jest również oparty na współczynniku wideo, więc jeśli Twój film ma współczynnik inny niż 16/9, będziesz chciał zmienić dolny procent wypełnienia. Poza tym działa po wyjęciu z pudełka. Przetestowano w IE9 +, Safari 9.0.1, Chrome 46 i Firefox 41.

EDYCJA (17 marca 2016 r.)

Od czasu, kiedy pisał tę odpowiedź Pisałem mały moduł do symulacji zarówno CSS background-size: coveri background-size: containna <video>elementach: http://codepen.io/benface/pen/NNdBMj

Obsługuje różne wyrównania wideo (podobnie jak background-position). Należy również pamiętać, że containimplementacja nie jest doskonała. W przeciwieństwie do background-size: containtego, nie przeskaluje wideo powyżej jego rzeczywistego rozmiaru, jeśli szerokość i wysokość kontenera są większe, ale myślę, że w niektórych przypadkach może być przydatne. Dodałem również specjalne fill-widthi fill-heightklasy, z których możesz korzystać razem, containaby uzyskać specjalną mieszankę containi cover... wypróbuj ją i nie krępuj się ją ulepszyć!

object-fit: cover to najlepsza odpowiedź z tym wypełnieniem IE, Safari.

https://github.com/constancecchen/object-fit-polyfill

Jest to wsparcie img, videoa pictureelementy.

CSS i little js mogą sprawić, że wideo zakryje tło i zostanie wyśrodkowane w poziomie.

CSS:

video#bgvid {
    position: absolute;
    bottom: 0px; 
    left: 50%; 
    min-width: 100%; 
    min-height: 100%; 
    width: auto; 
    height: auto; 
    z-index: -1; 
    overflow: hidden;
}

JS: (powiąż to ze zmianą rozmiaru okna i wywołaj raz osobno)

$('#bgvid').css({
    marginLeft : '-' + ($('#bgvid').width()/2) + 'px'
})

Zaraz po naszej długiej sekcji komentarzy myślę, że właśnie tego szukasz, jest oparty na jQuery:

HTML:

<img width="100%" id="img" src="http://uploads8.wikipaintings.org/images/william-adolphe-bouguereau/self-portrait-presented-to-m-sage-1886.jpg">

JS:

<script type="text/javascript">
window.onload = function(){
       var img = document.getElementById('img')
       if(img.clientHeight<$(window).height()){
            img.style.height=$(window).height()+"px";
       }
       if(img.clientWidth<$(window).width()){
            img.style.width=$(window).width()+"px";
       } 
}
​</script>​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

CSS:

body{
    overflow: hidden;
}

Powyższy kod korzysta z szerokości i wysokości przeglądarki, jeśli robisz to w ramach elementu div, musisz zmienić to na coś takiego:

Dla Div:

HTML:

<div style="width:100px; max-height: 100px;" id="div">
     <img width="100%" id="img" src="http://uploads8.wikipaintings.org/images/william-adolphe-bouguereau/self-portrait-presented-to-m-sage-1886.jpg">
</div>

JS:

<script type="text/javascript">
window.onload = function(){
       var img = document.getElementById('img')
       if(img.clientHeight<$('#div').height()){
            img.style.height=$('#div').height()+"px";
       }
       if(img.clientWidth<$('#div').width()){
            img.style.width=$('#div').width()+"px";
       } 
}
​</script>​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

CSS:

div{
   overflow: hidden;
}

Powinienem również stwierdzić, że przetestowałem tylko, że to Google Chrome ... tutaj jest jsfiddle: http://jsfiddle.net/ADCKk/

Najlepsza odpowiedź nie zmniejsza rozmiaru wideo, gdy szerokość przeglądarki jest mniejsza niż szerokość filmu. Spróbuj użyć tego kodu CSS (z #bgvid to identyfikator Twojego filmu wideo):

#bgvid {
     position: fixed;
     top: 50%;
     left: 50%;
     min-width: 100%;
     min-height: 100%;
     width: auto;
     height: auto;
     transform: translateX(-50%) translateY(-50%);
     -webkit-transform: translateX(-50%) translateY(-50%);
}

Jestem gunna i publikuję to rozwiązanie, ponieważ miałem ten problem, ale inne rozwiązania nie działały w mojej sytuacji ...

Myślę, że aby poprawnie zasymulować background-size:cover;właściwość css na elemencie zamiast właściwości background-image elementów, musiałbyś porównać proporcje obrazu z obecnym współczynnikiem kształtu okna, więc bez względu na rozmiar (a także w przypadku, gdy obraz jest wyższy niż szerszy) okno to element, który wypełnia okno (i również go wyśrodkowuje, chociaż nie wiem, czy to był wymóg) ....

używając obrazu, tylko dla uproszczenia, jestem pewien, że element wideo też będzie działał.

najpierw pobierz proporcje elementów (po załadowaniu), następnie dołącz moduł obsługi zmiany rozmiaru okna, uruchom go raz do początkowego rozmiaru:

var img = document.getElementById( "background-picture" ),
    imgAspectRatio;

img.onload = function() {
    // get images aspect ratio
    imgAspectRatio = this.height / this.width;
    // attach resize event and fire it once
    window.onresize = resizeBackground;
    window.onresize();
}

następnie w programie obsługi zmiany rozmiaru należy najpierw określić, czy szerokość lub wysokość wypełnienia ma być wypełniona, porównując bieżące proporcje okna z oryginalnymi proporcjami obrazu.

function resizeBackground( evt ) {

// get window size and aspect ratio
var windowWidth = window.innerWidth,
    windowHeight = window.innerHeight;
    windowAspectRatio = windowHeight / windowWidth;

//compare window ratio to image ratio so you know which way the image should fill
if ( windowAspectRatio < imgAspectRatio ) {
    // we are fill width
    img.style.width = windowWidth + "px";
    // and applying the correct aspect to the height now
    img.style.height = (windowWidth * imgAspectRatio) + "px";
    // this can be margin if your element is not positioned relatively, absolutely or fixed
    // make sure image is always centered
    img.style.left = "0px";
    img.style.top = (windowHeight - (windowWidth * imgAspectRatio)) / 2 + "px";
} else { // same thing as above but filling height instead
    img.style.height = windowHeight + "px";
    img.style.width = (windowHeight / imgAspectRatio) + "px";
    img.style.left = (windowWidth - (windowHeight / imgAspectRatio)) / 2 + "px";
    img.style.top = "0px";
}

}