{{article.content_lang.display}}

{{l10n_strings. AUTHOR_TOOLTIP_TEXT}}

Как смотреть видео на YouTube покадрово? Руководство 2022

Покадровый просмотр YouTube с помощью внешнего сайта

Хотя большинство видео на YouTube поддерживают покадровое воспроизведение, некоторые из них могут не поддерживаться.Затем вы можете смотреть их кадр за кадром, используя сторонний веб-сайт расширения.

Хотите знать, как это сделать? Вот упрощенная процедура!

• Найдите нужное видео в своем любимом браузере или войдите на YouTube.com с помощью своей учетной записи Google. Скопируйте URL нужного видео.
• Теперь откройте этот сторонний веб-сайт расширения и вставьте скопированный URL-адрес в данное поле
• Нажмите кнопку «Смотреть сейчас», чтобы запустить видео.
• Остановите видео там, где вы хотите, и установите кадр на 30 кадров в секунду после изменения шагов на «1 кадр».
• Теперь вы можете легко просматривать видео кадр за кадром с помощью кнопок вперед и назад.

В случае, если указанный выше сайт не работает, вот еще один похожий сайт для покадрового просмотра видео на YouTube. Шаги для этого несколько аналогичны упомянутым выше. Тем не менее, вы можете найти некоторые изменения в интерфейсе этого веб-сайта. Кроме того, эти веб-сайты совместимы как с настольными компьютерами, так и с мобильными телефонами.

Просмотр YouTube кадр за кадром с помощью VLC

Если вам не нравится часто пользоваться веб-браузерами, есть отличная альтернатива просмотру видео на YouTube покадрово и, т.

Давайте рассмотрим подробные шаги просмотра видео на YouTube покадрово с помощью VLC Player!

• Скопируйте ссылку на желаемое видео YouTube.
• Откройте проигрыватель VLC на своем компьютере.
• В меню выберите «носитель» и выберите «открытая сетевая система» в раскрывающемся меню.
• Вставьте ссылку на нужное видео в поле URL и нажмите кнопку воспроизведения, чтобы запустить потоковую передачу.
• Как только видео начнет воспроизводиться, вы можете использовать клавишу «E» на клавиатуре, чтобы видео воспроизводилось кадр за кадром.

Отличительной особенностью проигрывателя VLC является то, что вам не нужно нажимать клавишу каждый раз, когда вы хотите переместить кадр вперед.

Заключение

Чтобы собрать все детали видеороликов с практическими рекомендациями, необходимо просматривать кадр за кадром. Это упрощает и оптимизирует обучение. Тем не менее, немного сложно редактировать видеоролики YouTube с практическими рекомендациями кадр за кадром.

Лучший способ пройти покадрово самым простым способом — использовать видеоредактор для решения этого трюка. Новички также могут научиться делать кадр за кадром на YouTube.

Более того, просмотр видео на YouTube покадрово стал намного проще после использования онлайн-инструмента.Этой статьи достаточно, чтобы сделать вас экспертом в этом деле.

Если вы обычный зритель YouTube, вы можете использовать официальные сочетания клавиш YouTube. Для большей точности используйте покадровый видеоплеер онлайн.

Тем не менее, если вы хотите редактировать видео в дополнение к их просмотру, вам следует использовать медиаплеер VLC.

В чем разница между рамкой и границей?

Версия Swift: 5.4

Пол Хадсон    @twostraws    28 мая 2019 г.

Все подклассы UIView имеют два свойства, которые на первый взгляд кажутся похожими: кадр и границ .Оба возвращают CGRect — прямоугольник, содержащий их координаты X и Y, а также их ширину и высоту, — но это не значит, что они одинаковые .

В самом простом случае границы представления относятся к его координатам относительно его собственного пространства (как если бы остальная часть вашей иерархии представлений не существовала), тогда как его фрейм относится к его координатам относительно родительского пространства.

Это означает несколько вещей:

1. Если вы создаете вид по координатам X:0, Y:0, ширина:100, высота:100, его кадр и границы совпадают.
2. Если вы переместите этот вид на X:100, его рамка отразит это изменение, а его границы — нет. Помните, что границы относятся к собственному пространству представления, и внутри представления ничего не изменилось.
3. Если вы преобразуете представление, например, вращая или масштабируя его, рамка изменится, чтобы отразить это, но границы по-прежнему не изменятся — что касается вида внутри, он не изменился.

При изменении ширины или высоты кадра или границ другое значение обновляется для соответствия.Как правило, лучше изменить границ плюс центра и преобразовать , и пусть UIKit рассчитает для вас кадр .

СПОНСОРЫ Благодаря отслеживанию ошибок и производительности Sentry для iOS вы видите, что действительно важно для мобильных устройств, можете быстро решить любые проблемы с задержками и узнать, как работает каждый выпуск с течением времени.

Узнать больше

Спонсируйте взлом с помощью Swift и охватите крупнейшее в мире сообщество пользователей Swift!

Доступно с iOS 2.0

Аналогичные решения…

О базе знаний Swift

Это часть базы знаний Swift, бесплатной коллекции решений для часто используемых iOS с возможностью поиска.

Использование модификатора фрейма SwiftUI для изменения размера и выравнивания представлений

Встроенный модификатор кадра SwiftUI можно использовать как для назначения статической ширины или высоты заданному виду, так и для применения «подобных ограничениям» границ, в пределах которых представление может увеличиваться или уменьшаться в зависимости от его содержимого и окружения.

На самом базовом уровне два распространенных варианта использования модификатора кадра могут выглядеть следующим образом:

 
Значок структуры: Просмотр {
    имя переменной: строка
    var tintColor: Color = . blue

    var body: некоторый View {
        Изображение (имя системы: имя)
            .foregroundColor (оттенок цвета)
            .frame(ширина: 30, высота: 30)
    }
}


структура декоративного изображения: вид {
    имя переменной: строка

    var body: некоторый View {
        Изображение (имя)
            .изменяемый размер()
            .аспектное отношение (contentMode: .fit)
            .frame(maxWidth: 200)
    }
}  

Несмотря на то, что оба вышеупомянутых способа использования модификатора frame невероятно полезны, иногда мы можем не захотеть указывать какую-либо фиксированную метрику при принятии решения о том, как должны быть изменены наши представления. К счастью, есть также способ сделать данное представление бесконечно расширяемым , что может пригодиться во многих различных ситуациях.

Например, предположим, что мы работаем над представлением, которое отображает массив категорий в виде сетки из двух столбцов с использованием SwiftUI LazyVGrid type:

  struct CategoryGrid: View {
    var категории: [Категория]

    var body: некоторый View {
        LazyVGrid (столбцы: столбцы) {
            ForEach(categories) { категория в
                Текст(категория. имя)
                    .заполнение()
                    .background(категория.цвет)
                    .foregroundColor(.белый)
                    .уголРадиус(10)
            }
        }
        .заполнение()
    }

    частные переменные столбцы: [GridItem] {
        let item = GridItem(.flexible(минимум: 50, максимум: .infinity))
        вернуть [предмет, предмет]
    }
}  

Как вы можете видеть с помощью кнопки ПРЕДПРОСМОТР выше, наша сетка в настоящее время не выглядит великолепно, поскольку каждая ячейка имеет разный размер в зависимости от текста, который она отображает.

Поначалу это может показаться немного странным — учитывая, что мы указываем, что оба наших столбца должны быть гибкими с бесконечной максимальной шириной — но поскольку представление Text не растягивается, чтобы соответствовать своему контейнеру, каждое представление цвет фона просто займет размер самого текста.

К счастью, это еще одна проблема, которую можно легко решить с помощью модификатора frame в сочетании с константой CGFloat. infinity, которую мы также использовали выше при создании значений GridItem , представляющих наши столбцы.Вставив такой модификатор перед рендерингом нашего фона, мы можем сделать нашу сетку намного лучше:

  struct CategoryGrid: View {
    var категории: [Категория]

    var body: некоторый View {
        LazyVGrid (столбцы: столбцы) {
            ForEach(categories) { категория в
                Текст(категория.имя)
                    .заполнение()
                    .frame(maxWidth: .infinity)
                    .background(категория.цвет)
                    .foregroundColor(.белый)
                    .уголРадиус(10)
            }
        }
        .заполнение()
    }

    ...
}  

Еще раз, вы можете использовать кнопку ПРЕДВАРИТЕЛЬНЫЙ ПРОСМОТР , чтобы увидеть, как выглядит приведенный выше пример кода при визуализации.

Таким образом, применение модификатора frame с бесконечной максимальной шириной или максимальной высотой может быть отличным способом заставить данное представление SwiftUI растягиваться, чтобы заполнить все доступное пространство по горизонтальной или вертикальной оси.

Давайте рассмотрим другой пример, в котором мы создали InfoView , который можно использовать для отображения части информационного текста вместе с заголовком.Наша цель состоит в том, чтобы эти информационные представления всегда отображались по всей ширине экрана (за вычетом некоторого отступа), что, скорее всего, будет на iPhone, работающих в портретной ориентации, но в альбомной ориентации (или на iPad) может быть недостаточно текста. чтобы покрыть всю ширину экрана:

  struct InfoView: View {
    Название переменной: Строка
    переменный текст: строка

    var body: некоторый View {
        HStack (выравнивание: .top, интервал: 15) {
            Изображение (имя системы: "info.circle")
            VStack(выравнивание: .интерлиньяж, интервал: 10) {
                Текст(название).шрифт(.заголовок)
                Текст(текст)
            }
        }
        .заполнение()
        .foregroundColor(.белый)
        .background(Цвет.синий)
        .уголРадиус(20)
    }
}  

Одним из способов решения этой проблемы было бы использование Spacer для заполнения оставшегося горизонтального пространства, что фактически сделало бы наш InfoView всегда отображаемым по всей ширине его контейнера. Тем не менее, несмотря на то, что разделители действительно являются неотъемлемой частью системы компоновки SwiftUI, в этом случае добавление Spacer к нашему представлению может фактически привести к нарушению его портретной компоновки, поскольку по умолчанию разделители всегда занимают минимальное количество места, а наша HStack применяет интервал в 15 точек между каждым из своих элементов:

  struct InfoView: View {
    ...

    var body: некоторый View {
        HStack (выравнивание: .top, интервал: 15) {
            Изображение (имя системы: "info.circle")
            VStack (выравнивание: .leading, интервал: 10) {
                Текст(название).шрифт(.заголовок)
                Текст(текст)
            }
            Прокладка ()
        }
        ...
    }
}  

Как показано выше PREVIEW , из-за нашего добавленного Spacer наш текст больше не может отображаться на всей доступной ширине нашего представления.

Это еще один отличный вариант использования модификатора frame , который в этом случае может действовать как разделитель, если мы не только укажем infinity как его maxWidth , но и скажем ему выровнять его содержимое. по переднему краю — вот так:

  struct InfoView: View {
    ...

    var body: некоторый View {
        HStack (выравнивание: .top, интервал: 15) {
            Изображение (имя системы: "info.circle")
            VStack (выравнивание: .leading, интервал: 10) {
                Текст(название).шрифт(.заголовок)
                Текст(текст)
            }
            .frame(maxWidth: .infinity, выравнивание: .leading)
        }
        ...
    }
}  

Обратите внимание, что нам нужно указать .leading в качестве выравнивания для как нашего VStack , так и его модификатора frame , поскольку первый выравнивает содержимое стека (или два текста), а последний выравнивает укладывать себя в окружающую его рамку.

Конечно, вместо того, чтобы использовать .infinity в качестве maxWidth , мы могли бы также выбрать фиксированное значение, чтобы предотвратить слишком большое растяжение нашего представления на больших устройствах, таких как iPad. Но это решение, которое в конечном итоге сводится к тому, какой дизайн мы будем использовать при реализации каждого представления.

Инструменты Emerge: Оптимизируйте время запуска вашего приложения, размер двоичного файла и общую производительность с помощью передовых инструментов оптимизации и мониторинга приложений Emerge.Надежно измерьте размер приложения, ускорьте время запуска вашего приложения с помощью Launch Booster от Emerge и многое другое. Emerge активно используется ведущими мировыми командами мобильных разработчиков.

Понимание границ и рамок путем реализации простого ScrollView

Поскольку мы так часто используем UIView в нашем приложении, я был сбит с толку концепцией свойства границ
, документация описывает его как

Прямоугольник границ, который описывает положение и размер вида в собственной системе координат. На экране прямоугольник границ представляет ту же видимую часть представления, что и его прямоугольник рамки. По умолчанию исходная точка прямоугольника границ имеет значение (0, 0), но вы можете изменить это значение, чтобы отобразить разные части представления

Начало границ по умолчанию (0,0), а размер такой же, как размер прямоугольника кадра.

А давайте посмотрим на кадр свойство

Прямоугольник кадра, описывающий положение и размер вида в системе координат супервида

Термин собственная система координат действительно заставляет меня чувствовать себя некомфортно в первый раз
Другая проблема меня смущает, что Почему существуют границы и рамка, не было бы просто, если бы была только одна (скажем, есть только кадр , нет границы )

Итак, если у вас в голове крутится тот же вопрос, давайте попробуем реализовать простой UIScrollView для лучшего понимания границ и кадра
И наше прекрасное представление прокрутки будет выглядеть так. .(Как это просто)


LScrollView — это просто UIView

@интерфейс LScrollView : UIView
@конец
...

LScrollView* lScrollView = [[LScrollView alloc]initWithFrame:CGRectMake(0, 0, 320, 300)];
lScrollView.backgroundColor = [оранжевый цвет UIColor];

 

И нам, возможно, придется что-то делать в событии touchesMoved , предполагая, что единственной концепцией является кадр , без границ
каждый раз, когда мы панорамируем LScrollView , нам, возможно, придется менять кадры каждого подпредставления

    NSArray* subviews = [собственные подвиды];
    UITouch* touch = [касается любого объекта];
    //получаем текущую точку касания
    CGPoint pt = [touch locationInView:self];
    //получаем последнюю точку касания
    _lastPoint = [коснитесь предыдущегоLocationInView:self];
    _дельта = точка.х - _lastPoint.x;
    для (вид UIView * в подпредставлениях)
    {
        [просмотр setFrame:CGRectMake(view. frame.origin.x + _delta, view.frame.origin.y, view.frame.size.width, view.frame.size.height)];
    }
 

Все выглядит нормально, независимо от того, сколько у нас подвидов в нашем LScrollView

Мы повторяем каждое подпредставление и изменяем начало кадра, здесь есть проблема с производительностью,
Хорошо, давайте оставим это и посмотрим, как ограничивает ,
определяя собственную систему координат. означает, что система координат подвидов основана на
, например:
границы .происхождение суперпредставления: {0,0}
frame.origin дочернего представления: {10,10}

границы.происхождение
{0,0}
  +-------------------------------------------------------+
  | |
  | |
  | кадр.происхождение |
  | +-------------------------+ |
  | |{10,10} | |
  | | | |
  | | | |
  | | | |
  | | | |
  | +-------------------------+ |
  | |
  | |
  +-------------------------------------------------------+
 

конечная позиция дочернего представления: {10,10}
результат от
{child. frame.origin.x — super.bounds.origin.x, child.frame.origin.y — super.bounds.origin.y }

, если bounds.origin супервида равен {-10,-10}

границы.происхождение
{-10,-10}
  +--+----------------------------------------------------+
  | |
  | |
  | кадр.происхождение |
  | +-------------------------+ |
  | |{10,10} | |
  | | | |
  | | | |
  | | | |
  | | | |
  | +-------------------------+ |
  | |
  | |
  +-------------------------------------------------------+
 

конечная позиция дочернего представления: {20,20}
результат от
{child.frame.origin.x - super.bounds.origin.x,child.frame.origin.y - super.bounds.origin.y }
Итак, мы используем концепцию границ , чтобы снова реализовать наш scrollView

    UITouch* touch = [касается любого объекта];
    CGPoint pt = [touch locationInView:self];
    _offsetPoint = self.bounds.origin;
    _lastPoint = [коснитесь предыдущегоLocationInView:self];
    если(pt. x - _lastPoint.x == 0){
        вернуть;
    }
    // панорамирование вправо
    если (pt.x - _lastPoint.x > 0) {
        _право = ДА;
        _дельта = точка.х - _lastPoint.x;
        _offsetPoint.x -= _delta;
    }
    // панорамирование влево
    еще{
        _delta = _lastPoint.x - pt.x ;
        _offsetPoint.x += _delta;
    }
    [self setBounds:CGRectMake(_offsetPoint.x,0, self.frame.size.width, self.frame.size.height)];
 

, который работает быстрее и надежнее
И это оставляет мне еще один вопрос, Как Apple реализует scrollView , поскольку после изменения границ подпредставления каким-то образом должны изменить свое положение, но детали находятся за сценой

Ref:
Понимание представлений прокрутки
Cocoa: в чем разница между фреймом и границами?

фреймов в документах HTML

<ГОЛОВА>



  
      
      
  
  
  <БЕЗ КАДРОВ>
      
Этот документ набора фреймов содержит:
      <УЛ>
         
Небольшое содержание
         

 ---------------------------------------
| | |
| | |
| Кадр 1 | |
| | |
| | |
|---------| |
| | Кадр 3 |
| | |
| | |
| | |
| Кадр 2 | |
| | |
| | |
| | |
| | |
 ---------------------------------------
 

  ...остальное определение... 

 

  ...остальное определение... 

 

  ...остальное определение... 

 

  ...остальное определение... 

 

       ...содержимое первого кадра... 
     
          ...содержимое второго фрейма, первая строка... 
          ...содержимое второго кадра, вторая строка... 
     
       ...содержимое третьего фрейма... 

 

  w3.org/TR/html4/frameset.дтд"> <ГОЛОВА> <ОБЪЕКТ data="data.bar">  <НАБОР КАДРОВ>  <ГОЛОВА>  <ТЕЛО>  ...начало документа...  <Р>