Layer.h revision 2f5f8a51f5994cf14837030d4b3b252a9d1b950b 
1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_LAYER_H
18#define ANDROID_LAYER_H
19
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <EGL/egl.h>
24#include <EGL/eglext.h>
25
26#include <utils/RefBase.h>
27#include <utils/String8.h>
28#include <utils/Timers.h>
29
30#include <gfx/FloatRect.h>
31
32#include <ui/FrameStats.h>
33#include <ui/GraphicBuffer.h>
34#include <ui/PixelFormat.h>
35#include <ui/Region.h>
36
37#include <gui/ISurfaceComposerClient.h>
38
39#include <private/gui/LayerState.h>
40
41#include <list>
42
43#include "FrameTracker.h"
44#include "Client.h"
45#include "LayerVector.h"
46#include "MonitoredProducer.h"
47#include "SurfaceFlinger.h"
48#include "SurfaceFlingerConsumer.h"
49#include "Transform.h"
50
51#include "DisplayHardware/HWComposer.h"
52#include "RenderEngine/Mesh.h"
53#include "RenderEngine/Texture.h"
54
55namespace android {
56
57// ---------------------------------------------------------------------------
58
59class Client;
60class Colorizer;
61class DisplayDevice;
62class GraphicBuffer;
63class SurfaceFlinger;
64
65// ---------------------------------------------------------------------------
66
67/*
68 * A new BufferQueue and a new SurfaceFlingerConsumer are created when the
69 * Layer is first referenced.
70 *
71 * This also implements onFrameAvailable(), which notifies SurfaceFlinger
72 * that new data has arrived.
73 */
74class Layer : public SurfaceFlingerConsumer::ContentsChangedListener {
75    static int32_t sSequence;
76
77public:
78    mutable bool contentDirty;
79    // regions below are in window-manager space
80    Region visibleRegion;
81    Region coveredRegion;
82    Region visibleNonTransparentRegion;
83    Region surfaceDamageRegion;
84
85    // Layer serial number.  This gives layers an explicit ordering, so we
86    // have a stable sort order when their layer stack and Z-order are
87    // the same.
88    int32_t sequence;
89
90    enum { // flags for doTransaction()
91        eDontUpdateGeometryState = 0x00000001,
92        eVisibleRegion = 0x00000002,
93    };
94
95    struct Geometry {
96        uint32_t w;
97        uint32_t h;
98        Transform transform;
99
100        inline bool operator ==(const Geometry& rhs) const {
101            return (w == rhs.w && h == rhs.h) &&
102                    (transform.tx() == rhs.transform.tx()) &&
103                    (transform.ty() == rhs.transform.ty());
104        }
105        inline bool operator !=(const Geometry& rhs) const {
106            return !operator ==(rhs);
107        }
108    };
109
110    struct State {
111        Geometry active;
112        Geometry requested;
113        int32_t z;
114        uint32_t layerStack;
115#ifdef USE_HWC2
116        float alpha;
117#else
118        uint8_t alpha;
119#endif
120        uint8_t flags;
121        uint8_t mask;
122        uint8_t reserved[2];
123        int32_t sequence; // changes when visible regions can change
124        bool modified;
125
126        // Crop is expressed in layer space coordinate.
127        Rect crop;
128        Rect requestedCrop;
129
130        // finalCrop is expressed in display space coordinate.
131        Rect finalCrop;
132
133        // If set, defers this state update until the Layer identified by handle
134        // receives a frame with the given frameNumber
135        wp<IBinder> handle;
136        uint64_t frameNumber;
137
138        // the transparentRegion hint is a bit special, it's latched only
139        // when we receive a buffer -- this is because it's "content"
140        // dependent.
141        Region activeTransparentRegion;
142        Region requestedTransparentRegion;
143        android_dataspace dataSpace;
144
145        uint32_t appId;
146        uint32_t type;
147    };
148
149    // -----------------------------------------------------------------------
150
151    Layer(SurfaceFlinger* flinger, const sp<Client>& client,
152            const String8& name, uint32_t w, uint32_t h, uint32_t flags);
153
154    virtual ~Layer();
155
156    // the this layer's size and format
157    status_t setBuffers(uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
158
159    // modify current state
160    bool setPosition(float x, float y, bool immediate);
161    bool setLayer(int32_t z);
162    bool setSize(uint32_t w, uint32_t h);
163#ifdef USE_HWC2
164    bool setAlpha(float alpha);
165#else
166    bool setAlpha(uint8_t alpha);
167#endif
168    bool setMatrix(const layer_state_t::matrix22_t& matrix);
169    bool setTransparentRegionHint(const Region& transparent);
170    bool setFlags(uint8_t flags, uint8_t mask);
171    bool setCrop(const Rect& crop, bool immediate);
172    bool setFinalCrop(const Rect& crop);
173    bool setLayerStack(uint32_t layerStack);
174    bool setDataSpace(android_dataspace dataSpace);
175    uint32_t getLayerStack() const;
176    void deferTransactionUntil(const sp<IBinder>& handle, uint64_t frameNumber);
177    bool setOverrideScalingMode(int32_t overrideScalingMode);
178    void setInfo(uint32_t type, uint32_t appId);
179
180    // If we have received a new buffer this frame, we will pass its surface
181    // damage down to hardware composer. Otherwise, we must send a region with
182    // one empty rect.
183    void useSurfaceDamage();
184    void useEmptyDamage();
185
186    uint32_t getTransactionFlags(uint32_t flags);
187    uint32_t setTransactionFlags(uint32_t flags);
188
189    void computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh,
190            bool useIdentityTransform) const;
191    Rect computeBounds(const Region& activeTransparentRegion) const;
192    Rect computeBounds() const;
193
194    int32_t getSequence() const { return sequence; }
195
196    // -----------------------------------------------------------------------
197    // Virtuals
198
199    virtual const char* getTypeId() const { return "Layer"; }
200
201    /*
202     * isOpaque - true if this surface is opaque
203     *
204     * This takes into account the buffer format (i.e. whether or not the
205     * pixel format includes an alpha channel) and the "opaque" flag set
206     * on the layer.  It does not examine the current plane alpha value.
207     */
208    virtual bool isOpaque(const Layer::State& s) const;
209
210    /*
211     * isSecure - true if this surface is secure, that is if it prevents
212     * screenshots or VNC servers.
213     */
214    virtual bool isSecure() const;
215
216    /*
217     * isProtected - true if the layer may contain protected content in the
218     * GRALLOC_USAGE_PROTECTED sense.
219     */
220    virtual bool isProtected() const;
221
222    /*
223     * isVisible - true if this layer is visible, false otherwise
224     */
225    virtual bool isVisible() const;
226
227    /*
228     * isHiddenByPolicy - true if this layer has been forced invisible.
229     * just because this is false, doesn't mean isVisible() is true.
230     * For example if this layer has no active buffer, it may not be hidden by
231     * policy, but it still can not be visible.
232     */
233    virtual bool isHiddenByPolicy() const;
234
235    /*
236     * isFixedSize - true if content has a fixed size
237     */
238    virtual bool isFixedSize() const;
239
240protected:
241    /*
242     * onDraw - draws the surface.
243     */
244    virtual void onDraw(const sp<const DisplayDevice>& hw, const Region& clip,
245            bool useIdentityTransform) const;
246
247public:
248    // -----------------------------------------------------------------------
249
250#ifdef USE_HWC2
251    void setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z);
252    void forceClientComposition(int32_t hwcId);
253    void setPerFrameData(const sp<const DisplayDevice>& displayDevice);
254
255    // callIntoHwc exists so we can update our local state and call
256    // acceptDisplayChanges without unnecessarily updating the device's state
257    void setCompositionType(int32_t hwcId, HWC2::Composition type,
258            bool callIntoHwc = true);
259    HWC2::Composition getCompositionType(int32_t hwcId) const;
260
261    void setClearClientTarget(int32_t hwcId, bool clear);
262    bool getClearClientTarget(int32_t hwcId) const;
263
264    void updateCursorPosition(const sp<const DisplayDevice>& hw);
265#else
266    void setGeometry(const sp<const DisplayDevice>& hw,
267            HWComposer::HWCLayerInterface& layer);
268    void setPerFrameData(const sp<const DisplayDevice>& hw,
269            HWComposer::HWCLayerInterface& layer);
270    void setAcquireFence(const sp<const DisplayDevice>& hw,
271            HWComposer::HWCLayerInterface& layer);
272
273    Rect getPosition(const sp<const DisplayDevice>& hw);
274#endif
275
276    /*
277     * called after page-flip
278     */
279#ifdef USE_HWC2
280    void onLayerDisplayed(const sp<Fence>& releaseFence);
281#else
282    void onLayerDisplayed(const sp<const DisplayDevice>& hw,
283            HWComposer::HWCLayerInterface* layer);
284#endif
285
286    bool shouldPresentNow(const DispSync& dispSync) const;
287
288    /*
289     * called before composition.
290     * returns true if the layer has pending updates.
291     */
292    bool onPreComposition(nsecs_t refreshStartTime);
293
294    /*
295     * called after composition.
296     * returns true if the layer latched a new buffer this frame.
297     */
298    bool onPostComposition(
299            const std::shared_ptr<FenceTime>& glDoneFence,
300            const std::shared_ptr<FenceTime>& presentFence,
301            const std::shared_ptr<FenceTime>& retireFence);
302
303#ifdef USE_HWC2
304    // If a buffer was replaced this frame, release the former buffer
305    void releasePendingBuffer(nsecs_t dequeueReadyTime);
306#endif
307
308    /*
309     * draw - performs some global clipping optimizations
310     * and calls onDraw().
311     */
312    void draw(const sp<const DisplayDevice>& hw, const Region& clip) const;
313    void draw(const sp<const DisplayDevice>& hw, bool useIdentityTransform) const;
314    void draw(const sp<const DisplayDevice>& hw) const;
315
316    /*
317     * doTransaction - process the transaction. This is a good place to figure
318     * out which attributes of the surface have changed.
319     */
320    uint32_t doTransaction(uint32_t transactionFlags);
321
322    /*
323     * setVisibleRegion - called to set the new visible region. This gives
324     * a chance to update the new visible region or record the fact it changed.
325     */
326    void setVisibleRegion(const Region& visibleRegion);
327
328    /*
329     * setCoveredRegion - called when the covered region changes. The covered
330     * region corresponds to any area of the surface that is covered
331     * (transparently or not) by another surface.
332     */
333    void setCoveredRegion(const Region& coveredRegion);
334
335    /*
336     * setVisibleNonTransparentRegion - called when the visible and
337     * non-transparent region changes.
338     */
339    void setVisibleNonTransparentRegion(const Region&
340            visibleNonTransparentRegion);
341
342    /*
343     * latchBuffer - called each time the screen is redrawn and returns whether
344     * the visible regions need to be recomputed (this is a fairly heavy
345     * operation, so this should be set only if needed). Typically this is used
346     * to figure out if the content or size of a surface has changed.
347     */
348    Region latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime);
349
350    bool isPotentialCursor() const { return mPotentialCursor;}
351
352    /*
353     * called with the state lock when the surface is removed from the
354     * current list
355     */
356    void onRemoved();
357
358
359    // Updates the transform hint in our SurfaceFlingerConsumer to match
360    // the current orientation of the display device.
361    void updateTransformHint(const sp<const DisplayDevice>& hw) const;
362
363    /*
364     * returns the rectangle that crops the content of the layer and scales it
365     * to the layer's size.
366     */
367    Rect getContentCrop() const;
368
369    /*
370     * Returns if a frame is queued.
371     */
372    bool hasQueuedFrame() const { return mQueuedFrames > 0 ||
373            mSidebandStreamChanged || mAutoRefresh; }
374
375#ifdef USE_HWC2
376    // -----------------------------------------------------------------------
377
378    bool hasHwcLayer(int32_t hwcId) {
379        if (mHwcLayers.count(hwcId) == 0) {
380            return false;
381        }
382        if (mHwcLayers[hwcId].layer->isAbandoned()) {
383            ALOGI("Erasing abandoned layer %s on %d", mName.string(), hwcId);
384            mHwcLayers.erase(hwcId);
385            return false;
386        }
387        return true;
388    }
389
390    std::shared_ptr<HWC2::Layer> getHwcLayer(int32_t hwcId) {
391        if (mHwcLayers.count(hwcId) == 0) {
392            return nullptr;
393        }
394        return mHwcLayers[hwcId].layer;
395    }
396
397    void setHwcLayer(int32_t hwcId, std::shared_ptr<HWC2::Layer>&& layer) {
398        if (layer) {
399            mHwcLayers[hwcId].layer = layer;
400        } else {
401            mHwcLayers.erase(hwcId);
402        }
403    }
404
405#endif
406    // -----------------------------------------------------------------------
407
408    void clearWithOpenGL(const sp<const DisplayDevice>& hw) const;
409    void setFiltering(bool filtering);
410    bool getFiltering() const;
411
412    // only for debugging
413    inline const sp<GraphicBuffer>& getActiveBuffer() const { return mActiveBuffer; }
414
415    inline  const State&    getDrawingState() const { return mDrawingState; }
416    inline  const State&    getCurrentState() const { return mCurrentState; }
417    inline  State&          getCurrentState()       { return mCurrentState; }
418
419
420    /* always call base class first */
421    void dump(String8& result, Colorizer& colorizer) const;
422#ifdef USE_HWC2
423    static void miniDumpHeader(String8& result);
424    void miniDump(String8& result, int32_t hwcId) const;
425#endif
426    void dumpFrameStats(String8& result) const;
427    void dumpFrameEvents(String8& result);
428    void clearFrameStats();
429    void logFrameStats();
430    void getFrameStats(FrameStats* outStats) const;
431
432    std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush);
433
434    void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry,
435            FrameEventHistoryDelta* outDelta);
436
437    bool getTransformToDisplayInverse() const;
438
439    Transform getTransform() const;
440
441    void traverseInReverseZOrder(const std::function<void(Layer*)>& exec);
442    void traverseInZOrder(const std::function<void(Layer*)>& exec);
443
444    void addChild(const sp<Layer>& layer);
445    // Returns index if removed, or negative value otherwise
446    // for symmetry with Vector::remove
447    ssize_t removeChild(const sp<Layer>& layer);
448    sp<Layer> getParent() const { return mParent.promote(); }
449    bool hasParent() const { return getParent() != nullptr; }
450
451    Rect computeScreenBounds(bool reduceTransparentRegion = true) const;
452    bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
453
454    // Copy the current list of children to the drawing state. Called by
455    // SurfaceFlinger to complete a transaction.
456    void commitChildList();
457
458    int32_t getZ() const;
459protected:
460    // constant
461    sp<SurfaceFlinger> mFlinger;
462    /*
463     * Trivial class, used to ensure that mFlinger->onLayerDestroyed(mLayer)
464     * is called.
465     */
466    class LayerCleaner {
467        sp<SurfaceFlinger> mFlinger;
468        wp<Layer> mLayer;
469    protected:
470        ~LayerCleaner() {
471            // destroy client resources
472            mFlinger->onLayerDestroyed(mLayer);
473        }
474    public:
475        LayerCleaner(const sp<SurfaceFlinger>& flinger,
476                const sp<Layer>& layer)
477            : mFlinger(flinger), mLayer(layer) {
478        }
479    };
480
481
482    virtual void onFirstRef();
483
484
485
486private:
487    friend class SurfaceInterceptor;
488    // Interface implementation for SurfaceFlingerConsumer::ContentsChangedListener
489    virtual void onFrameAvailable(const BufferItem& item) override;
490    virtual void onFrameReplaced(const BufferItem& item) override;
491    virtual void onSidebandStreamChanged() override;
492
493    void commitTransaction(const State& stateToCommit);
494
495    // needsLinearFiltering - true if this surface's state requires filtering
496    bool needsFiltering(const sp<const DisplayDevice>& hw) const;
497
498    uint32_t getEffectiveUsage(uint32_t usage) const;
499
500    gfx::FloatRect computeCrop(const sp<const DisplayDevice>& hw) const;
501    // Compute the initial crop as specified by parent layers and the SurfaceControl
502    // for this layer. Does not include buffer crop from the IGraphicBufferProducer
503    // client, as that should not affect child clipping. Returns in screen space.
504    Rect computeInitialCrop(const sp<const DisplayDevice>& hw) const;
505    bool isCropped() const;
506    static bool getOpacityForFormat(uint32_t format);
507
508    // drawing
509    void clearWithOpenGL(const sp<const DisplayDevice>& hw,
510            float r, float g, float b, float alpha) const;
511    void drawWithOpenGL(const sp<const DisplayDevice>& hw,
512            bool useIdentityTransform) const;
513
514    // Temporary - Used only for LEGACY camera mode.
515    uint32_t getProducerStickyTransform() const;
516
517    // Loads the corresponding system property once per process
518    static bool latchUnsignaledBuffers();
519
520    void setParent(const sp<Layer>& layer);
521
522    // -----------------------------------------------------------------------
523
524    class SyncPoint
525    {
526    public:
527        explicit SyncPoint(uint64_t frameNumber) : mFrameNumber(frameNumber),
528                mFrameIsAvailable(false), mTransactionIsApplied(false) {}
529
530        uint64_t getFrameNumber() const {
531            return mFrameNumber;
532        }
533
534        bool frameIsAvailable() const {
535            return mFrameIsAvailable;
536        }
537
538        void setFrameAvailable() {
539            mFrameIsAvailable = true;
540        }
541
542        bool transactionIsApplied() const {
543            return mTransactionIsApplied;
544        }
545
546        void setTransactionApplied() {
547            mTransactionIsApplied = true;
548        }
549
550    private:
551        const uint64_t mFrameNumber;
552        std::atomic<bool> mFrameIsAvailable;
553        std::atomic<bool> mTransactionIsApplied;
554    };
555
556    // SyncPoints which will be signaled when the correct frame is at the head
557    // of the queue and dropped after the frame has been latched. Protected by
558    // mLocalSyncPointMutex.
559    Mutex mLocalSyncPointMutex;
560    std::list<std::shared_ptr<SyncPoint>> mLocalSyncPoints;
561
562    // SyncPoints which will be signaled and then dropped when the transaction
563    // is applied
564    std::list<std::shared_ptr<SyncPoint>> mRemoteSyncPoints;
565
566    uint64_t getHeadFrameNumber() const;
567    bool headFenceHasSignaled() const;
568
569    // Returns false if the relevant frame has already been latched
570    bool addSyncPoint(const std::shared_ptr<SyncPoint>& point);
571
572    void pushPendingState();
573    void popPendingState(State* stateToCommit);
574    bool applyPendingStates(State* stateToCommit);
575
576    void clearSyncPoints();
577
578    // Returns mCurrentScaling mode (originating from the
579    // Client) or mOverrideScalingMode mode (originating from
580    // the Surface Controller) if set.
581    uint32_t getEffectiveScalingMode() const;
582public:
583    /*
584     * The layer handle is just a BBinder object passed to the client
585     * (remote process) -- we don't keep any reference on our side such that
586     * the dtor is called when the remote side let go of its reference.
587     *
588     * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
589     * this layer when the handle is destroyed.
590     */
591    class Handle : public BBinder, public LayerCleaner {
592        public:
593            Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
594                : LayerCleaner(flinger, layer), owner(layer) {}
595
596            wp<Layer> owner;
597    };
598
599    sp<IBinder> getHandle();
600    sp<IGraphicBufferProducer> getProducer() const;
601    const String8& getName() const;
602    void notifyAvailableFrames();
603private:
604
605    // -----------------------------------------------------------------------
606
607    // Check all of the local sync points to ensure that all transactions
608    // which need to have been applied prior to the frame which is about to
609    // be latched have signaled
610    bool allTransactionsSignaled();
611
612    // constants
613    sp<SurfaceFlingerConsumer> mSurfaceFlingerConsumer;
614    sp<IGraphicBufferProducer> mProducer;
615    uint32_t mTextureName;      // from GLES
616    bool mPremultipliedAlpha;
617    String8 mName;
618    PixelFormat mFormat;
619
620    // these are protected by an external lock
621    State mCurrentState;
622    State mDrawingState;
623    volatile int32_t mTransactionFlags;
624
625    // Accessed from main thread and binder threads
626    Mutex mPendingStateMutex;
627    Vector<State> mPendingStates;
628
629    // thread-safe
630    volatile int32_t mQueuedFrames;
631    volatile int32_t mSidebandStreamChanged; // used like an atomic boolean
632
633    // Timestamp history for UIAutomation. Thread safe.
634    FrameTracker mFrameTracker;
635
636    // Timestamp history for the consumer to query.
637    // Accessed by both consumer and producer on main and binder threads.
638    Mutex mFrameEventHistoryMutex;
639    ConsumerFrameEventHistory mFrameEventHistory;
640    FenceTimeline mAcquireTimeline;
641    FenceTimeline mReleaseTimeline;
642
643    // main thread
644    sp<GraphicBuffer> mActiveBuffer;
645    sp<NativeHandle> mSidebandStream;
646    Rect mCurrentCrop;
647    uint32_t mCurrentTransform;
648    uint32_t mCurrentScalingMode;
649    // We encode unset as -1.
650    int32_t mOverrideScalingMode;
651    bool mCurrentOpacity;
652    bool mBufferLatched = false;  // TODO: Use mActiveBuffer?
653    std::atomic<uint64_t> mCurrentFrameNumber;
654    uint64_t mPreviousFrameNumber; // Only accessed on the main thread.
655    bool mRefreshPending;
656    bool mFrameLatencyNeeded;
657    // Whether filtering is forced on or not
658    bool mFiltering;
659    // Whether filtering is needed b/c of the drawingstate
660    bool mNeedsFiltering;
661    // The mesh used to draw the layer in GLES composition mode
662    mutable Mesh mMesh;
663    // The texture used to draw the layer in GLES composition mode
664    mutable Texture mTexture;
665
666#ifdef USE_HWC2
667    // HWC items, accessed from the main thread
668    struct HWCInfo {
669        HWCInfo()
670          : layer(),
671            forceClientComposition(false),
672            compositionType(HWC2::Composition::Invalid),
673            clearClientTarget(false) {}
674
675        std::shared_ptr<HWC2::Layer> layer;
676        bool forceClientComposition;
677        HWC2::Composition compositionType;
678        bool clearClientTarget;
679        Rect displayFrame;
680        gfx::FloatRect sourceCrop;
681    };
682    std::unordered_map<int32_t, HWCInfo> mHwcLayers;
683#else
684    bool mIsGlesComposition;
685#endif
686
687    // page-flip thread (currently main thread)
688    bool mProtectedByApp; // application requires protected path to external sink
689
690    // protected by mLock
691    mutable Mutex mLock;
692    // Set to true once we've returned this surface's handle
693    mutable bool mHasSurface;
694    const wp<Client> mClientRef;
695
696    // This layer can be a cursor on some displays.
697    bool mPotentialCursor;
698
699    // Local copy of the queued contents of the incoming BufferQueue
700    mutable Mutex mQueueItemLock;
701    Condition mQueueItemCondition;
702    Vector<BufferItem> mQueueItems;
703    std::atomic<uint64_t> mLastFrameNumberReceived;
704    bool mUpdateTexImageFailed; // This is only accessed on the main thread.
705
706    bool mAutoRefresh;
707    bool mFreezePositionUpdates;
708
709    // Child list about to be committed/used for editing.
710    LayerVector mCurrentChildren;
711    // Child list used for rendering.
712    LayerVector mDrawingChildren;
713
714    wp<Layer> mParent;
715};
716
717// ---------------------------------------------------------------------------
718
719}; // namespace android
720
721#endif // ANDROID_LAYER_H
722